DEV Community: artydev

Sovereign Dev Agent — .NET 10 single-file port (Native AOT compatible)

artydev — Sun, 21 Jun 2026 21:51:20 +0000

A nice .net agent:

// ==========================================================================
// Sovereign Dev Agent — .NET 10 single-file port (Native AOT compatible)
// ==========================================================================
// Run with:     dotnet run Program.cs
// Publish AOT: dotnet publish -p:PublishAot=true
//
// Requires: ALBERT_API_KEY environment variable.
// ==========================================================================

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

// --------------------------------------------------------------------
// Configuration
// --------------------------------------------------------------------
string albertApiKey = Environment.GetEnvironmentVariable("OPENROUTER_API_KEY") ?? "VOTRE_CLE_ALBERT";
const string BaseUrl = "https://openrouter.ai/api/v1/chat/completions";
const string ModelName = "openai/gpt-oss-120b";

if (string.IsNullOrWhiteSpace(albertApiKey) || albertApiKey == "VOTRE_CLE_ALBERT")
{
    Console.Error.WriteLine("❌ Error: Please define your ALBERT_API_KEY environment variable.");
    Environment.Exit(1);
}

// --------------------------------------------------------------------
// Persistent state
// --------------------------------------------------------------------
string currentWorkingDir = Directory.GetCurrentDirectory();
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", albertApiKey);

// --------------------------------------------------------------------
// DRY helper: path resolution & validation
// --------------------------------------------------------------------
string ResolveAndValidatePath(string relativeOrAbsolutePath, bool checkExists = true)
{
    string resolvedPath = Path.GetFullPath(Path.Combine(currentWorkingDir, relativeOrAbsolutePath));
    if (checkExists && !File.Exists(resolvedPath) && !Directory.Exists(resolvedPath))
    {
        throw new FileNotFoundException($"Target path does not exist: {resolvedPath}");
    }
    return resolvedPath;
}

// --------------------------------------------------------------------
// JsonElement helpers (AOT-safe: no reflection, no serializer)
// --------------------------------------------------------------------
static string? GetStringProp(JsonElement obj, string name)
{
    if (obj.ValueKind == JsonValueKind.Object && obj.TryGetProperty(name, out var prop) && prop.ValueKind == JsonValueKind.String)
    {
        return prop.GetString();
    }
    return null;
}

// --------------------------------------------------------------------
// Local tools — updated to support async tool invocation naturally
// --------------------------------------------------------------------
Task<ToolResult> ListDirectoryAsync(JsonElement args)
{
    try
    {
        string dirPath = GetStringProp(args, "dirPath") ?? ".";
        string targetPath = ResolveAndValidatePath(dirPath);

        // EnumerateFileSystemInfos surfaces directory-vs-file via Attributes from the
        // same underlying syscall as enumeration, avoiding a second per-entry stat
        // call that Directory.Exists(entry) would otherwise require.
        var files = new List<(string, string)>();
        foreach (var entry in new DirectoryInfo(targetPath).EnumerateFileSystemInfos())
        {
            bool isFolder = (entry.Attributes & FileAttributes.Directory) == FileAttributes.Directory;
            files.Add((entry.Name, isFolder ? "folder" : "file"));
        }

        return Task.FromResult(ToolResult.Ok(currentWorkingDir: currentWorkingDir, files: files));
    }
    catch (Exception err)
    {
        return Task.FromResult(ToolResult.Fail(err.Message));
    }
}

async Task<ToolResult> ReadProjectFileAsync(JsonElement args)
{
    try
    {
        string? filePath = GetStringProp(args, "filePath");
        if (string.IsNullOrEmpty(filePath))
            return ToolResult.Fail("filePath is required");

        string targetPath = ResolveAndValidatePath(filePath);

        // Optimize: Check file size before reading to avoid blowing out memory limits
        var fileInfo = new FileInfo(targetPath);
        const int MaxAllowedReadBytes = 120_000; // ~120KB maximum chunk threshold

        if (fileInfo.Length > MaxAllowedReadBytes)
        {
            // Stream only the head block of the huge target file seamlessly
            using var fs = new FileStream(targetPath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, useAsync: true);
            byte[] buffer = new byte[MaxAllowedReadBytes];
            int readBytes = await fs.ReadAsync(buffer, 0, MaxAllowedReadBytes);

            string partialContent = Encoding.UTF8.GetString(buffer, 0, readBytes);
            return ToolResult.Ok(content: partialContent + $"\n\n[... TRUNCATED SYSTEM OPTIMIZATION: File size is {fileInfo.Length} bytes. Read limit capped at {MaxAllowedReadBytes} bytes to prevent network latency loops ...] ");
        }

        string content = await File.ReadAllTextAsync(targetPath, Encoding.UTF8);
        return ToolResult.Ok(content: content);
    }
    catch (Exception err)
    {
        return ToolResult.Fail(err.Message);
    }
}

async Task<ToolResult> WriteProjectFileAsync(JsonElement args)
{
    try
    {
        string? filePath = GetStringProp(args, "filePath");
        string content = GetStringProp(args, "content") ?? "";
        if (string.IsNullOrEmpty(filePath))
            return ToolResult.Fail("filePath is required");

        string targetPath = ResolveAndValidatePath(filePath, checkExists: false);
        string? dir = Path.GetDirectoryName(targetPath);

        if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
            Directory.CreateDirectory(dir);

        await File.WriteAllTextAsync(targetPath, content, Encoding.UTF8);
        return ToolResult.Ok(message: $"Successfully wrote file to {targetPath}");
    }
    catch (Exception err)
    {
        return ToolResult.Fail(err.Message);
    }
}

Task<ToolResult> ChangeDirectoryAsync(JsonElement args)
{
    try
    {
        string? targetPathArg = GetStringProp(args, "targetPath");
        if (string.IsNullOrEmpty(targetPathArg))
            return Task.FromResult(ToolResult.Fail("targetPath is required"));

        string newPath = ResolveAndValidatePath(targetPathArg);
        if (!Directory.Exists(newPath))
            return Task.FromResult(ToolResult.Fail($"Not a directory: {newPath}"));

        currentWorkingDir = newPath;
        return Task.FromResult(ToolResult.Ok(currentWorkingDir: currentWorkingDir));
    }
    catch (Exception err)
    {
        return Task.FromResult(ToolResult.Fail(err.Message));
    }
}

async Task<ToolResult> ExecuteTerminalCommandAsync(JsonElement args)
{
    try
    {
        string? command = GetStringProp(args, "command");
        if (string.IsNullOrEmpty(command))
            return ToolResult.Fail("command is required");

        Console.WriteLine($"\n   [Terminal Executing]: {command}");

        var psi = new ProcessStartInfo
        {
            FileName = OperatingSystem.IsWindows() ? "cmd.exe" : "/bin/bash",
            ArgumentList = { OperatingSystem.IsWindows() ? "/c" : "-c", command },
            WorkingDirectory = currentWorkingDir,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            CreateNoWindow = true
        };

        using var process = new Process { StartInfo = psi };

        var stdoutBuilder = new StringBuilder();
        var stderrBuilder = new StringBuilder();

        process.OutputDataReceived += (s, e) => { if (e.Data != null) stdoutBuilder.AppendLine(e.Data); };
        process.ErrorDataReceived += (s, e) => { if (e.Data != null) stderrBuilder.AppendLine(e.Data); };

        process.Start();
        process.BeginOutputReadLine();
        process.BeginErrorReadLine();

        await process.WaitForExitAsync();

        string stdout = stdoutBuilder.ToString();
        string stderr = stderrBuilder.ToString();

        if (process.ExitCode != 0)
        {
            return ToolResult.Fail($"Command exited with code {process.ExitCode}", stderr: stderr);
        }

        return ToolResult.Ok(stdout: stdout);
    }
    catch (Exception err)
    {
        return ToolResult.Fail(err.Message);
    }
}

// Map of tool name -> asynchronous function execution targets
var localToolsMap = new Dictionary<string, Func<JsonElement, Task<ToolResult>>>
{
    ["listDirectory"] = ListDirectoryAsync,
    ["readProjectFile"] = ReadProjectFileAsync,
    ["writeProjectFile"] = WriteProjectFileAsync,
    ["changeDirectory"] = ChangeDirectoryAsync,
    ["executeTerminalCommand"] = ExecuteTerminalCommandAsync
};

// --------------------------------------------------------------------
// Tool schema sent to the model — written directly with Utf8JsonWriter.
// --------------------------------------------------------------------
void WriteToolsSchema(Utf8JsonWriter w)
{
    w.WriteStartArray();

    void WriteTool(string name, string description, Action<Utf8JsonWriter> writeProperties, string[] required)
    {
        w.WriteStartObject();
        w.WriteString("type", "function");
        w.WriteStartObject("function");
        w.WriteString("name", name);
        w.WriteString("description", description);
        w.WriteStartObject("parameters");
        w.WriteString("type", "object");
        w.WriteStartObject("properties");
        writeProperties(w);
        w.WriteEndObject();
        if (required.Length > 0)
        {
            w.WriteStartArray("required");
            foreach (var r in required) w.WriteStringValue(r);
            w.WriteEndArray();
        }
        w.WriteEndObject();
        w.WriteEndObject();
        w.WriteEndObject();
    }

    void WriteStringParam(Utf8JsonWriter writer, string name, string? description = null)
    {
        writer.WriteStartObject(name);
        writer.WriteString("type", "string");
        if (description is not null) writer.WriteString("description", description);
        writer.WriteEndObject();
    }

    WriteTool(
        "listDirectory",
        "List files and folders in a target directory",
        wr => WriteStringParam(wr, "dirPath", "Relative or absolute directory path"),
        required: Array.Empty<string>());

    WriteTool(
        "readProjectFile",
        "Read contents of a file",
        wr => WriteStringParam(wr, "filePath"),
        required: new[] { "filePath" });

    WriteTool(
        "writeProjectFile",
        "Write content to a file, creates directory branches recursively if missing",
        wr =>
        {
            WriteStringParam(wr, "filePath");
            WriteStringParam(wr, "content");
        },
        required: new[] { "filePath", "content" });

    WriteTool(
        "changeDirectory",
        "Change current working directory path context",
        wr => WriteStringParam(wr, "targetPath"),
        required: new[] { "targetPath" });

    WriteTool(
        "executeTerminalCommand",
        "Execute arbitrary bash shell commands natively with a 60s timeout.",
        wr => WriteStringParam(wr, "command"),
        required: new[] { "command" });

    w.WriteEndArray();
}

// --------------------------------------------------------------------
// Conversation history storage helpers
// --------------------------------------------------------------------
string BuildUserOrSystemMessage(string role, string content)
{
    using var ms = new MemoryStream();
    using (var w = new Utf8JsonWriter(ms))
    {
        w.WriteStartObject();
        w.WriteString("role", role);
        w.WriteString("content", content);
        w.WriteEndObject();
    }
    return Encoding.UTF8.GetString(ms.ToArray());
}

string BuildToolMessage(string toolCallId, string toolName, string contentJson)
{
    using var ms = new MemoryStream();
    using (var w = new Utf8JsonWriter(ms))
    {
        w.WriteStartObject();
        w.WriteString("role", "tool");
        w.WriteString("tool_call_id", toolCallId);
        w.WriteString("name", toolName);
        w.WriteString("content", contentJson);
        w.WriteEndObject();
    }
    return Encoding.UTF8.GetString(ms.ToArray());
}

// --------------------------------------------------------------------
// Shared payload builder (avoids re-parsing each history entry's JSON
// on every loop turn — history strings are already well-formed JSON
// produced by our own builders, so we splice their raw bytes directly
// instead of round-tripping through JsonDocument.Parse + WriteTo).
// --------------------------------------------------------------------
byte[] BuildChatPayload(List<string> history, bool stream)
{
    using var ms = new MemoryStream();
    using (var w = new Utf8JsonWriter(ms))
    {
        w.WriteStartObject();
        w.WriteString("model", ModelName);

        w.WriteStartArray("messages");
        foreach (var msgJson in history)
        {
            w.WriteRawValue(msgJson, skipInputValidation: true);
        }
        w.WriteEndArray();

        w.WritePropertyName("tools");
        WriteToolsSchema(w);

        w.WriteString("tool_choice", "auto");
        if (stream) w.WriteBoolean("stream", true);
        w.WriteEndObject();
    }

    return ms.ToArray();
}

// --------------------------------------------------------------------
// Albert Non-Streaming API call (Used exclusively for Tool Dispatch evaluations)
// --------------------------------------------------------------------
async Task<JsonElement> QueryAlbertAsync(List<string> history)
{
    byte[] payloadBytes = BuildChatPayload(history, stream: false);

    using var content = new ByteArrayContent(payloadBytes);
    content.Headers.ContentType = new MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
    using var response = await httpClient.PostAsync(BaseUrl, content);

    string body = await response.Content.ReadAsStringAsync();
    if (!response.IsSuccessStatusCode)
    {
        throw new Exception($"Albert API Error ({(int)response.StatusCode}): {body}");
    }

    using var responseDoc = JsonDocument.Parse(body);
    var message = responseDoc.RootElement.GetProperty("choices")[0].GetProperty("message");
    return message.Clone();
}

// --------------------------------------------------------------------
// Albert Streaming API call (AOT-Safe real-time streaming evaluator)
// --------------------------------------------------------------------
async Task<string> QueryAlbertStreamAsync(List<string> history, AnsiStreamParser streamParser)
{
    byte[] payloadBytes = BuildChatPayload(history, stream: true);

    using var request = new HttpRequestMessage(HttpMethod.Post, BaseUrl)
    {
        Content = new ByteArrayContent(payloadBytes)
    };
    request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };

    using var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);

    if (!response.IsSuccessStatusCode)
    {
        string errorBody = await response.Content.ReadAsStringAsync();
        throw new Exception($"Albert API Error ({(int)response.StatusCode}): {errorBody}");
    }

    using var stream = await response.Content.ReadAsStreamAsync();
    using var reader = new StreamReader(stream, Encoding.UTF8);

    var fullContentBuilder = new StringBuilder();

    while (await reader.ReadLineAsync() is string line)
    {
        if (string.IsNullOrWhiteSpace(line)) continue;
        if (line.StartsWith("data: [DONE]")) break;

        if (line.StartsWith("data: "))
        {
            string jsonChunk = line[6..].Trim();
            if (string.IsNullOrEmpty(jsonChunk)) continue;

            byte[] chunkBytes = Encoding.UTF8.GetBytes(jsonChunk);
            var jsonReader = new Utf8JsonReader(chunkBytes);

            while (jsonReader.Read())
            {
                if (jsonReader.TokenType == JsonTokenType.PropertyName && jsonReader.ValueTextEquals("content"))
                {
                    jsonReader.Read();
                    string? token = jsonReader.GetString();
                    if (!string.IsNullOrEmpty(token))
                    {
                        fullContentBuilder.Append(token);
                        string formattedToken = streamParser.AppendChunk(token);
                        Console.Write(formattedToken);
                    }
                }
            }
        }
    }

    Console.WriteLine();
    return fullContentBuilder.ToString();
}

// --------------------------------------------------------------------
// Runtime engine
// --------------------------------------------------------------------
async Task HandleChatAsync(string userInput)
{
    string cleanInput = userInput.Trim();

    if (string.IsNullOrEmpty(cleanInput))
    {
        PromptUser();
        return;
    }

    // 2. Fast-Track File Viewers (Bypasses LLM network loops entirely with Instant Pipeline)
    if (cleanInput.StartsWith("cat ", StringComparison.OrdinalIgnoreCase) || 
        cleanInput.StartsWith("type ", StringComparison.OrdinalIgnoreCase) ||
        cleanInput.StartsWith("gc ", StringComparison.OrdinalIgnoreCase))
    {
        try
        {
            string filename = cleanInput.Split(' ', 2)[1].Trim();
            string targetPath = ResolveAndValidatePath(filename);

            Console.WriteLine($"\n\x1b[1;35m📄 Local File Stream ({filename}):\x1b[0m");
            var streamParser = new AnsiStreamParser();

            Console.Write(streamParser.ForceEnterCodeBlock());

            using var fileStream = new FileStream(targetPath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, useAsync: true);
            using var reader = new StreamReader(fileStream, Encoding.UTF8);

            string? lineStr;
            while ((lineStr = await reader.ReadLineAsync()) != null)
            {
                Console.Write(streamParser.AppendChunk(lineStr + "\n"));
            }

            Console.Write(streamParser.ForceExitCodeBlock());
            PromptUser();
            return; 
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ Local file read failed: {ex.Message}");
            PromptUser();
            return;
        }
    }

    // 3. Application Exit Commands
    if (string.Equals(cleanInput, "exit", StringComparison.OrdinalIgnoreCase) ||
        string.Equals(cleanInput, "quit", StringComparison.OrdinalIgnoreCase))
    {
        Console.WriteLine("\nSovereign Dev Agent closed.");
        return;
    }

const string SystemPrompt =
@"You are an expert, senior full-stack software engineer and local development agent, and also a capable, friendly general-purpose conversational assistant. Decide for yourself, per message, which mode the user actually needs — most messages will be one or the other, not both.

MODE SELECTION:
- Use tools (listDirectory, readProjectFile, writeProjectFile, changeDirectory, executeTerminalCommand) only when the user's request requires touching the filesystem, running commands, or inspecting/modifying the actual project — e.g. ""fix this bug"", ""add a function to X"", ""run the tests"", ""what's in this folder"".
- Answer directly in conversation, with no tool calls, for everything else — explanations, opinions, brainstorming, general knowledge, casual chat, conceptual or ""should I use X or Y"" questions, or anything where you already have what you need to answer. Do not call a tool just to look busy or thorough if the user's question doesn't actually require touching the workspace.
- If you're unsure which mode fits, default to answering conversationally first; only reach for tools once it's clear the user wants you to act on the project.

WHEN ACTING AS A DEV AGENT (tool calling), follow these OPERATIONAL PRINCIPLES:
1. ANALYSIS FIRST: Before writing files or executing scripts, inspect the existing directory structure and relevant files to understand the project architecture.
2. DEFENSIVE CODING: Implement comprehensive error handling, type checks, and edge-case validations in all code you generate. Do not write placeholder code or ""TODOs"".
3. STEP-BY-STEP EXECUTION: Break down complex engineering objectives into deliberate, sequential tool calls. Verify the outcome of a step (e.g., compile or test results) before moving to the next.
4. ATOMICITY: Keep file modifications precise. Avoid rewriting massive files if only a single function needs optimization.
5. SELF-CORRECTION: If a terminal command returns a standard error (stderr) or a compilation failure, analyze the output, fix the root cause, and re-run the process immediately.
6. PROFESSIONAL PRESENTATION OF THE WORK — consistent naming and formatting conventions for the language/stack in use, clear and minimal comments only where they add real value, sensible project structure, no leftover debug prints or commented-out dead code, and meaningful commit-quality messages if you generate any.

FINAL RESPONSE FORMATTING (applies once you're done with tool calls, if any, and are giving your concluding answer):
- If the turn involved tool calls: structure your concluding answer like a polished engineering handoff, not a raw log dump.
  - Open with a one- or two-sentence summary of what was accomplished.
  - Use clear Markdown structure: short headings or bold labels for sections, bullet points or numbered lists for steps/changes, and fenced code blocks with the correct language tag for any code, commands, or file paths.
  - If you changed or created files, list them explicitly (e.g. as a short table or bullet list of path → purpose).
  - If you ran commands, summarize the outcome in plain language rather than pasting raw terminal output verbatim; quote only the specific error or result line if it's relevant.
  - End with next steps, caveats, or follow-up suggestions when relevant (e.g. ""run the test suite"", ""set the FOO env var before deploying"").
  - Never present a final answer as an unformatted wall of text when the content has any structure to it (multiple files, multiple steps, comparisons, etc.).
- If the turn was purely conversational (no tool calls): just answer naturally, like a normal chat response. Use Markdown structure (headings, bullets, code blocks) only when the content actually has that kind of structure — a short answer or a casual remark should stay a short, plain response, not be forced into a report format.
- In both cases, keep tone confident, concise, and free of filler — no rambling, no unnecessary apologies, no exposing internal reasoning or tool mechanics.

You have total technical authority to manipulate files and execute shell strings within this workspace to achieve the user's goal, and full latitude to talk about anything else the user brings up as a normal conversational partner.";

    var localHistory = new List<string>
    {
        BuildUserOrSystemMessage("system", SystemPrompt),
        BuildUserOrSystemMessage("user", $"Current Working Directory Context: {currentWorkingDir}\nUser Query: {cleanInput}")
    };

    bool keepLooping = true;
    int loopsCounter = 0;
    const int MaxLoops = 12;

    try
    {
        while (keepLooping && loopsCounter < MaxLoops)
        {
            loopsCounter++;

            JsonElement message = await QueryAlbertAsync(localHistory);

            bool hasToolCalls = message.TryGetProperty("tool_calls", out var toolCallsEl) &&
                                 toolCallsEl.ValueKind == JsonValueKind.Array &&
                                 toolCallsEl.GetArrayLength() > 0;

            if (hasToolCalls)
            {
                using (var ms = new MemoryStream())
                {
                    using (var w = new Utf8JsonWriter(ms))
                    {
                        message.WriteTo(w);
                    }
                    localHistory.Add(Encoding.UTF8.GetString(ms.ToArray()));
                }

                var toolCall = toolCallsEl[0];
                var function = toolCall.GetProperty("function");
                string toolName = function.GetProperty("name").GetString() ?? "";
                string toolCallId = toolCall.TryGetProperty("id", out var idEl) ? (idEl.GetString() ?? "") : "";
                string argumentsJson = function.TryGetProperty("arguments", out var argsEl)
                    ? (argsEl.GetString() ?? "{}")
                    : "{}";

                Console.WriteLine($"\n🤖 [Agent Step {loopsCounter}]: Executing {toolName}");

                if (localToolsMap.TryGetValue(toolName, out var executionFunction))
                {
                    JsonDocument argsDoc = JsonDocument.Parse(string.IsNullOrEmpty(argumentsJson) ? "{}" : argumentsJson);
                    ToolResult toolResult;
                    using (argsDoc)
                    {
                        toolResult = await executionFunction(argsDoc.RootElement);
                    }

                    string resultStr = toolResult.ToJson();

                    string preview = resultStr.Length > 150 ? resultStr.Substring(0, 150) + "..." : resultStr;
                    Console.WriteLine($"⚙️ [Result]: {preview}");

                    localHistory.Add(BuildToolMessage(toolCallId, toolName, resultStr));
                }
                else
                {
                    Console.WriteLine($"❌ Tool {toolName} missing implementation.");
                    keepLooping = false;
                }
            }
            else
            {
                Console.Write("\n\x1b[1;35m🤖 Agent Albert:\x1b[0m\n");

                var streamParser = new AnsiStreamParser();
                string streamedContent = await QueryAlbertStreamAsync(localHistory, streamParser);

                localHistory.Add(BuildUserOrSystemMessage("assistant", streamedContent));
                keepLooping = false;
            }
        }

        if (loopsCounter >= MaxLoops)
        {
            Console.WriteLine($"\n⚠️ Safety Loop Cap reached ({MaxLoops} actions).");
        }
    }
    catch (Exception error)
    {
        Console.Error.WriteLine($"\n❌ Runtime Engine Error: {error.Message}");
    }

    PromptUser();
}

void PromptUser()
{
    Console.WriteLine($"\n[{currentWorkingDir}]");
    Console.Write("You: ");
}

// --------------------------------------------------------------------
// Entry point loop
// --------------------------------------------------------------------
Console.WriteLine("=========================================================");
Console.WriteLine("🔓 Unrestricted Multi-Turn State-Streaming Agent — .NET 10");
Console.WriteLine("=========================================================");

PromptUser();
string? inputLine;
while ((inputLine = Console.ReadLine()) != null)
{
    await HandleChatAsync(inputLine);

    if (string.Equals(inputLine.Trim(), "exit", StringComparison.OrdinalIgnoreCase) ||
        string.Equals(inputLine.Trim(), "quit", StringComparison.OrdinalIgnoreCase))
    {
        break;
    }
}

// ==========================================================================
// Type declarations (Placed last to satisfy Top-Level Statements constraint)
// ==========================================================================

sealed class ToolResult
{
    public bool Success { get; init; }
    public string? Error { get; init; }
    public string? CurrentWorkingDir { get; init; }
    public string? Message { get; init; }
    public string? Content { get; init; }
    public string? Stdout { get; init; }
    public string? Stderr { get; init; }
    public List<(string Name, string Type)>? Files { get; init; }

    public static ToolResult Ok(string? currentWorkingDir = null, string? message = null,
        string? content = null, string? stdout = null, List<(string, string)>? files = null) =>
        new()
        {
            Success = true,
            CurrentWorkingDir = currentWorkingDir,
            Message = message,
            Content = content,
            Stdout = stdout,
            Files = files
        };

    public static ToolResult Fail(string error, string? stderr = null) =>
        new() { Success = false, Error = error, Stderr = stderr };

    public string ToJson()
    {
        using var ms = new MemoryStream();
        using (var w = new Utf8JsonWriter(ms))
        {
            w.WriteStartObject();

            if (Error is not null)
            {
                w.WriteBoolean("success", false);
                w.WriteString("error", Error);
                if (Stderr is not null) w.WriteString("stderr", Stderr);
            }
            else
            {
                w.WriteBoolean("success", true);
                if (CurrentWorkingDir is not null) w.WriteString("currentWorkingDir", CurrentWorkingDir);
                if (Message is not null) w.WriteString("message", Message);
                if (Content is not null) w.WriteString("content", Content);
                if (Stdout is not null) w.WriteString("stdout", Stdout);
                if (Files is not null)
                {
                    w.WriteStartArray("files");
                    foreach (var (name, type) in Files)
                    {
                        w.WriteStartObject();
                        w.WriteString("name", name);
                        w.WriteString("type", type);
                        w.WriteEndObject();
                    }
                    w.WriteEndArray();
                }
            }

            w.WriteEndObject();
        }

        return Encoding.UTF8.GetString(ms.ToArray());
    }
}

sealed class AnsiStreamParser
{
    private const string Reset = "\x1b[0m";
    private const string Green = "\x1b[32m";
    private const string DarkGray = "\x1b[90m";
    private const string CodeBg = "\x1b[48;5;235m";
    private const string CodeFg = "\x1b[38;5;250m";

    private enum ParserState { Text, CodeBlock, InlineCode }
    private ParserState _state = ParserState.Text;

    private readonly StringBuilder _buffer = new();

    public string ForceEnterCodeBlock()
    {
        _state = ParserState.CodeBlock;
        _buffer.Clear();
        return $"\n{DarkGray}----------------------------------{Reset}\n{CodeBg}{CodeFg}";
    }

    public string ForceExitCodeBlock()
    {
        _state = ParserState.Text;
        _buffer.Clear();
        return $"{Reset}\n{DarkGray}----------------------------------{Reset}\n";
    }

    public string AppendChunk(string chunk)
    {
        if (string.IsNullOrEmpty(chunk))
            return string.Empty;

        var output = new StringBuilder();

        foreach (char c in chunk)
        {
            switch (_state)
            {
                case ParserState.Text:
                    if (c == '`')
                    {
                        _state = ParserState.InlineCode;
                        output.Append(Green);
                    }
                    else
                    {
                        output.Append(c);
                    }
                    break;

                case ParserState.InlineCode:
                    if (c == '`')
                    {
                        _state = ParserState.Text;
                        output.Append(Reset);
                    }
                    else
                    {
                        output.Append(c);
                    }
                    break;

                case ParserState.CodeBlock:
                    if (c == '`')
                    {
                        // naive fence detection: ```
{% endraw %}
 ends block
                        if (_buffer.Length >= 2 && _buffer[^1] == '{% raw %}`' && _buffer[^2] == '`{% endraw %}')
                        {
                            _buffer.Clear();
                            output.Append(ForceExitCodeBlock());
                            continue;
                        }

                        _buffer.Append(c);
                        output.Append(c);
                    }
                    else
                    {
                        _buffer.Clear();
                        output.Append(c);
                    }
                    break;
            }
        }

        return output.ToString();
    }
}

{% raw %}

Native AOT-Compatible C# Local AI Agent with Ollama Tool Calling

artydev — Sun, 14 Jun 2026 12:36:23 +0000

Nice tool for personal usage:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

// ─────────────────────────────────────────────────────────────
// AOT SERIALIZATION CONTEXT
// ─────────────────────────────────────────────────────────────
[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
[JsonSerializable(typeof(OllamaRequest))]
[JsonSerializable(typeof(OllamaResponse))]
[JsonSerializable(typeof(OllamaOptions))]
internal partial class OllamaJsonContext : JsonSerializerContext { }


// ─────────────────────────────────────────────────────────────
// TOOL REGISTRY
// ─────────────────────────────────────────────────────────────

public record ToolParam(string Name, string Type, string Description);

public record ToolDefinition(
    string Name,
    string Description,
    IReadOnlyList<ToolParam> Params,
    Func<Dictionary<string, string>, string> Handler
);

public static class ToolRegistry
{
    public static readonly IReadOnlyList<ToolDefinition> Tools = new List<ToolDefinition>
    {
        // ── greet_user ────────────────────────────────────────
        new(
            Name: "greet_user",
            Description: "MUST be called whenever the user introduces themselves or provides their name " +
                         "(e.g. 'I am John', 'my name is Alice', 'hi I'm Marco', 'call me Sam'). " +
                         "Extract the name and call this tool immediately — do NOT reply in plain text.",
            Params: new[] { new ToolParam("name", "string", "The user's first name as stated") },
            Handler: args => args.TryGetValue("name", out var name) ? $"Bonjour {name}!" : "Error: 'name' parameter not found."
        ),

        // ── add_numbers ───────────────────────────────────────
        new(
            Name: "add_numbers",
            Description: "Add two numbers together and return the result.",
            Params: new[]
            {
                new ToolParam("a", "number", "First operand"),
                new ToolParam("b", "number", "Second operand")
            },
            Handler: args =>
            {
                if (args.TryGetValue("a", out var strA) && args.TryGetValue("b", out var strB) &&
                    double.TryParse(strA, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out double a) &&
                    double.TryParse(strB, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out double b))
                {
                    return (a + b).ToString(System.Globalization.CultureInfo.InvariantCulture);
                }
                return "Error: Could not parse 'a' or 'b' as valid numbers.";
            }
        )
    };

    private static readonly Dictionary<string, ToolDefinition> _index =
        Tools.ToDictionary(t => t.Name, StringComparer.OrdinalIgnoreCase);

    public static bool TryGet(string name, out ToolDefinition? tool) => _index.TryGetValue(name, out tool);
}


// ─────────────────────────────────────────────────────────────
// PROMPT BUILDER
// ─────────────────────────────────────────────────────────────
public static class PromptBuilder
{
private const string BasePrompt = """
        You are a precise, helpful assistant with access to a dynamic set of tools.
        Your primary job is to have natural, useful conversations. Tools exist only to augment
        your responses when genuinely needed — never as a reflex.

        ══════════════════════════════════════════
        TOOL CALL FORMAT
        ══════════════════════════════════════════
        All tools are called using self-closing XML tags:
          <call:TOOL_NAME param1="value1" param2="value2" />

        Rules for values:
          • Strings  → quote as-is:          name="Alice"
          • Numbers  → raw value, no units:  a="12"  b="7.5"
          • Booleans → lowercase string:     enabled="true"
          • Lists    → comma-separated:      items="a,b,c"

        ══════════════════════════════════════════
        AVAILABLE TOOLS
        ══════════════════════════════════════════
        {TOOLS_BLOCK}

        ══════════════════════════════════════════
        DECISION FRAMEWORK
        ══════════════════════════════════════════
        STEP 1 — THINK silently before every response:
          a) What is the user actually asking for?
          b) Does any listed tool directly serve that need?
          c) Would the tool's output be the core of my answer?

        STEP 2 — Use a tool ONLY when ALL of these are true:
          ✔ A listed tool exists that matches the user's intent
          ✔ The tool's output is the primary value of the response
          ✔ The required parameters can be extracted unambiguously from the input

        STEP 3 — Do NOT use a tool when:
          ✘ The question is answerable directly from your internal general knowledge
          ✘ A tool exists but its output is peripheral to the answer
          ✘ Parameters are missing or ambiguous — ask the user to clarify instead (CASE D)
          ✘ No listed tool matches — IMMEDIATELY drop all tool logic and answer naturally

        ══════════════════════════════════════════
        OUTPUT FORMAT — FOUR STRICT CASES
        ══════════════════════════════════════════
        CASE A — No tool matches / General Knowledge → Respond naturally using your own brain. 
          *CRITICAL:* Do not mention tools, do not apologize about missing tools, and do not explain what you can or cannot do. Just give the answer directly.
          User:  "Who invented the telephone?"
          You:   "Alexander Graham Bell is credited with inventing the telephone in 1876."
          User:  "Who was Albert Einstein?"
          You:   "Albert Einstein was a theoretical physicist who developed the theory of relativity..."

        ──────────────────────────────────────────
        CASE B — Tool matches → output ONLY the XML tag. Zero preamble. Zero trailing text.
          User:  "Add 15 and 27"
          You:   <call:add_numbers a="15" b="27" />

          User:  "Hey, I'm Sophie!"
          You:   <call:greet_user name="Sophie" />

        ──────────────────────────────────────────
        CASE C — After a tool result is returned → incorporate it naturally. Be concise and friendly.
          Result: "[Result for add_numbers]: 42"
          You:    "15 + 27 equals 42."

        ──────────────────────────────────────────
        CASE D — Parameters missing or ambiguous → ask ONE targeted clarifying question. No tool call yet.
          User:  "Add the numbers"
          You:   "I'd be happy to add them — which two numbers should I use?"

        ══════════════════════════════════════════
        CHAINING & MULTIPLE TOOLS
        ══════════════════════════════════════════
        If a task requires multiple tools:
          • You MAY output multiple <call:...> tags in a single response if independent actions are needed.
          • Wait for the results, then synthesize all outputs into one coherent answer.

        ══════════════════════════════════════════
        ABSOLUTE PROHIBITIONS
        ══════════════════════════════════════════
          ✘ NEVER use the words "tool", "XML", "tag", "parameter", or "framework" in your conversation with the user.
          ✘ Never invent tool names not listed in AVAILABLE TOOLS above.
          ✘ Never output partial, nested, or malformed XML.
          ✘ Never mix tool XML with surrounding prose in the same response.
          ✘ Never guess parameter values — if uncertain, trigger CASE D.
          ✘ Never say "I don't have a tool for that" — if no tool applies, just act like a normal AI assistant.
          ✘ Never use a tool for rhetorical, emotional, or illustrative purposes.
        """;

    public static string Build(IReadOnlyList<ToolDefinition> tools)
    {
        var block = new StringBuilder();
        foreach (var tool in tools)
        {
            var paramStr = string.Join(" ", tool.Params.Select(p => $"{p.Name}=\"{{{p.Type}}}\""));
            block.AppendLine($"• {tool.Name}: {tool.Description}");
            block.AppendLine($"  Signature: <call:{tool.Name} {paramStr} />");
            block.AppendLine($"  Parameters:");
            foreach (var p in tool.Params)
                block.AppendLine($"    - {p.Name} ({p.Type}): {p.Description}");
            block.AppendLine();
        }
        return BasePrompt.Replace("{TOOLS_BLOCK}", block.ToString().TrimEnd());
    }
}


// ─────────────────────────────────────────────────────────────
// TOOL EXECUTOR — 100% Native AOT Source-Generated Parser
// ─────────────────────────────────────────────────────────────
public static partial class ToolExecutor
{
    [GeneratedRegex(@"<call:\s*([a-zA-Z0-9_]+)\s*(.*?)/?>", RegexOptions.Singleline)]
    private static partial Regex ToolTagRx();

    [GeneratedRegex(@"([a-zA-Z0-9_]+)\s*=\s*(?:""([^""]*)""|'([^']*)'|([^\s/>]+))")]
    private static partial Regex AttrRx();

    public static List<string> ExecuteAll(string raw)
    {
        var results = new List<string>();
        var matches = ToolTagRx().Matches(raw);

        foreach (Match match in matches)
        {
            string toolName = match.Groups[1].Value;
            string attrsString = match.Groups[2].Value;

            if (!ToolRegistry.TryGet(toolName, out var tool))
            {
                results.Add($"Error: Unknown tool '{toolName}'.");
                continue;
            }

            var args = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            foreach (Match attrMatch in AttrRx().Matches(attrsString))
            {
                string key = attrMatch.Groups[1].Value;
                string value = attrMatch.Groups[2].Success ? attrMatch.Groups[2].Value
                             : attrMatch.Groups[3].Success ? attrMatch.Groups[3].Value
                             : attrMatch.Groups[4].Value;

                args[key] = value;
            }

            try
            {
                string output = tool!.Handler(args);
                results.Add($"[Result for {toolName}]: {output}");
            }
            catch (Exception ex)
            {
                results.Add($"[Error in {toolName}]: {ex.Message}");
            }
        }

        return results;
    }
}


// ─────────────────────────────────────────────────────────────
// MAIN CHAT LOOP
// ─────────────────────────────────────────────────────────────
public class OllamaChat
{
    const string OllamaUrl = "http://localhost:11434/api/chat";
    const string ModelName = "qwen2.5:3b";

    static readonly HttpClient Http = new();

    static async Task Main()
    {
        string modelName = args.Length > 0 ? args[0] : "qwen2.5:3b";

        string systemPrompt = PromptBuilder.Build(ToolRegistry.Tools);
        var history = new List<OllamaMessage> { new() { Role = "system", Content = systemPrompt } };

        Console.WriteLine($"=== Engine Ready ({ModelName}) — {ToolRegistry.Tools.Count} tool(s) loaded ===");
        foreach (var t in ToolRegistry.Tools) Console.WriteLine($"  • {t.Name}");
        Console.WriteLine();

        while (true)
        {
            Console.Write("You: ");
            string? input = Console.ReadLine();
            if (string.IsNullOrEmpty(input) || input == "exit") break;

            history.Add(new OllamaMessage { Role = "user", Content = input });

            // Step 1: Manage context windows prior to execution
            ManageContextWindow(history);

            Console.Write("AI: ");
            string reply;

            try
            {
                // Step 2 & 3: Stream and intercept with an associated 30s timeout execution window
                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
                reply = await StreamAndCapture(history, cts.Token);
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("\n⚠️ [Error: Ollama took too long to respond. Request aborted.]\n");
                history.RemoveAt(history.Count - 1); 
                continue;
            }

            List<string> toolResults = ToolExecutor.ExecuteAll(reply);

            if (toolResults.Any())
            {
                string combinedResults = string.Join("\n", toolResults);
                Console.WriteLine("⚙️  [Executing System Tools...]");

                history.Add(new OllamaMessage { Role = "assistant", Content = reply });
                history.Add(new OllamaMessage { Role = "user",      Content = combinedResults });

                // Step 1: Manage window space again in case of massive tool outputs
                ManageContextWindow(history);

                Console.Write("AI: ");
                try
                {
                    using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
                    string finalReply = await StreamAndCapture(history, cts.Token);
                    Console.WriteLine();
                    history.Add(new OllamaMessage { Role = "assistant", Content = finalReply });
                }
                catch (OperationCanceledException)
                {
                    Console.WriteLine("\n⚠️ [Error: Ollama timed out while processing tool results.]\n");
                    history.RemoveRange(history.Count - 2, 2); 
                }
            }
            else
            {
                // Defensive Edge-Case: If the stream was muted because it started with '<' 
                // but no valid tools were processed, print the raw output so information isn't lost.
                if (reply.StartsWith("<"))
                {
                    Console.Write(reply);
                }
                Console.WriteLine();
                history.Add(new OllamaMessage { Role = "assistant", Content = reply });
            }
        }
    }

    // Step 3: Implements In-Stream Interception & Muting
    static async Task<string> StreamAndCapture(List<OllamaMessage> history, CancellationToken cancellationToken)
    {
        var sb = new StringBuilder();
        var req = new OllamaRequest
        {
            Model   = ModelName,
            Stream  = true,
            Messages = history,
            Options = new OllamaOptions { Temperature = 0.0f }
        };

        var json = JsonSerializer.Serialize(req, OllamaJsonContext.Default.OllamaRequest);
        using var resp = await Http.PostAsync(
            OllamaUrl, new StringContent(json, Encoding.UTF8, "application/json"), cancellationToken);

        using var stream = await resp.Content.ReadAsStreamAsync(cancellationToken);
        using var reader = new StreamReader(stream);

        bool isToolCall = false;
        bool checkedFirstChar = false;

        while (await reader.ReadLineAsync(cancellationToken) is { } line)
        {
            var chunk = JsonSerializer.Deserialize(line, OllamaJsonContext.Default.OllamaResponse);
            if (chunk?.Message?.Content != null)
            {
                string content = chunk.Message.Content;
                sb.Append(content);

                // Instantly evaluate the first incoming byte chunk
                if (!checkedFirstChar && sb.Length > 0)
                {
                    if (sb[0] == '<')
                    {
                        isToolCall = true; // Mute console pipeline
                    }
                    checkedFirstChar = true;
                }

                if (!isToolCall)
                {
                    Console.Write(content);
                }
            }
            if (chunk?.Done == true) break;
        }
        return sb.ToString();
    }

    // Step 1: Implements Context Window Management
    static void ManageContextWindow(List<OllamaMessage> history)
    {
        const int MaxContextChars = 12000; // Safe allocation headroom threshold (~3000 tokens)
        while (history.Count > 1 && history.Sum(m => m.Content?.Length ?? 0) > MaxContextChars)
        {
            history.RemoveAt(1); // Safely drop index 1 (oldest turn), keeping system prompt intact at index 0
        }
    }
}


// ─────────────────────────────────────────────────────────────
// OLLAMA DATA MODELS
// ─────────────────────────────────────────────────────────────
public class OllamaOptions
{
    [JsonPropertyName("temperature")] public float Temperature { get; set; }
}

public class OllamaRequest
{
    [JsonPropertyName("model")]    public string             Model    { get; set; } = "";
    [JsonPropertyName("stream")]   public bool               Stream   { get; set; }
    [JsonPropertyName("messages")] public List<OllamaMessage> Messages { get; set; } = new();
    [JsonPropertyName("options")]  public OllamaOptions?     Options  { get; set; }
}

public class OllamaMessage
{
    [JsonPropertyName("role")]    public string Role    { get; set; } = "";
    [JsonPropertyName("content")] public string Content { get; set; } = "";
}

public class OllamaResponse
{
    [JsonPropertyName("message")] public OllamaMessage? Message { get; set; }
    [JsonPropertyName("done")]    public bool           Done    { get; set; }
}

Multi-Session AI Multiplexer That Runs Entirely in Your Browser

artydev — Wed, 27 May 2026 12:12:26 +0000

Use this script to chat and launch commands given an MCP server running on localhost:3000

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>OllamaTerminal — Dracula</title>
<link rel="preconnect" href="https://fonts.googleapis.com" />
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
<link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;600;700&family=Fira+Code:wght@300;400;500;600&display=swap" rel="stylesheet" />

<style>
/* ─── DRACULA PALETTE ─────────────────────────────────────────── */
:root {
  --bg:          #282a36;
  --bg-dark:     #1e1f29;
  --bg-darker:   #191a24;
  --surface:     #21222c;
  --surface2:    #2d2f3d;
  --border:      #44475a;
  --comment:     #6272a4;
  --fg:          #f8f8f2;
  --fg-dim:      #c8c8c0;

  --cyan:        #8be9fd;
  --green:       #50fa7b;
  --orange:      #ffb86c;
  --pink:        #ff79c6;
  --purple:      #bd93f9;
  --red:         #ff5555;
  --yellow:      #f1fa8c;

  --accent:      #bd93f9;
  --accent-glow: rgba(189,147,249,0.25);
  --green-glow:  rgba(80,250,123,0.2);
  --cyan-glow:   rgba(139,233,253,0.2);

  --radius:      4px;
  --font-mono:   'JetBrains Mono', 'Fira Code', monospace;
}

*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }

html, body {
  height: 100%;
  background: var(--bg-darker);
  color: var(--fg);
  font-family: var(--font-mono);
  font-size: 13px;
  line-height: 1.55;
  overflow: hidden;
}

/* ─── SCANLINE OVERLAY ────────────────────────────────────────── */
body::before {
  content: '';
  position: fixed; inset: 0; z-index: 9999;
  pointer-events: none;
  background: repeating-linear-gradient(
    0deg,
    transparent,
    transparent 2px,
    rgba(0,0,0,0.07) 2px,
    rgba(0,0,0,0.07) 4px
  );
}

/* ─── CHROME / WINDOW ─────────────────────────────────────────── */
#app {
  display: flex;
  flex-direction: column;
  height: 100vh;
  border: 1px solid var(--border);
  background: var(--bg);
  position: relative;
}

/* ─── TITLE BAR ───────────────────────────────────────────────── */
#titleBar {
  display: flex;
  align-items: center;
  gap: 8px;
  padding: 6px 14px;
  background: var(--bg-darker);
  border-bottom: 1px solid var(--border);
  flex-shrink: 0;
  user-select: none;
}

.traffic-lights { display: flex; gap: 6px; align-items: center; }
.tl { width: 12px; height: 12px; border-radius: 50%; cursor: pointer; transition: filter .15s; }
.tl:hover { filter: brightness(1.3); }
.tl-red    { background: var(--red); }
.tl-yellow { background: var(--yellow); }
.tl-green  { background: var(--green); }

#titleText {
  flex: 1;
  text-align: center;
  font-size: 11px;
  font-weight: 500;
  color: var(--comment);
  letter-spacing: 0.12em;
  text-transform: uppercase;
}

.title-badge {
  font-size: 10px;
  padding: 1px 7px;
  background: var(--surface2);
  border: 1px solid var(--border);
  border-radius: 10px;
  color: var(--purple);
  letter-spacing: 0.08em;
}

/* ─── SESSION / MULTIPLEXER BAR ───────────────────────────────── */
#sessionBar {
  display: flex;
  align-items: stretch;
  gap: 2px;
  padding: 4px 8px 0;
  background: var(--bg-darker);
  border-bottom: 1px solid var(--border);
  flex-shrink: 0;
  min-height: 34px;
  flex-wrap: wrap;
}

.session-wrapper {
  display: flex;
  align-items: center;
  position: relative;
}

.session-tab {
  display: inline-flex;
  align-items: center;
  padding: 4px 12px;
  font-size: 11.5px;
  font-weight: 500;
  cursor: pointer;
  color: var(--comment);
  border: 1px solid transparent;
  border-bottom: none;
  border-radius: var(--radius) var(--radius) 0 0;
  background: transparent;
  transition: color .15s, background .15s, border-color .15s;
  white-space: nowrap;
  letter-spacing: 0.03em;
  position: relative;
  top: 1px;
}

.session-tab:hover {
  color: var(--fg-dim);
  background: var(--surface);
  border-color: var(--border);
}

.session-tab.active {
  color: var(--purple);
  background: var(--bg);
  border-color: var(--border);
  border-bottom-color: var(--bg);
  font-weight: 600;
}

.session-tab.active::before {
  content: '▸ ';
  color: var(--pink);
  font-size: 10px;
}

.delete-btn {
  font-size: 9px;
  color: var(--comment);
  cursor: pointer;
  padding: 0 4px;
  transition: color .15s;
  opacity: 0.5;
}
.session-wrapper:hover .delete-btn { opacity: 1; }
.delete-btn:hover { color: var(--red); }

.rename-input {
  background: var(--surface2);
  border: 1px solid var(--purple);
  border-radius: var(--radius);
  color: var(--fg);
  font-family: var(--font-mono);
  font-size: 11.5px;
  padding: 2px 8px;
  outline: none;
  width: 110px;
  box-shadow: 0 0 6px var(--accent-glow);
}

/* ─── BAR ACTIONS (right-side controls) ──────────────────────── */
.bar-actions-group {
  display: flex;
  align-items: center;
  gap: 8px;
  margin-left: auto;
  padding: 0 4px 4px;
}

.model-selector-wrapper {
  display: flex;
  align-items: center;
  gap: 5px;
  font-size: 10.5px;
  color: var(--comment);
}

.model-select-native {
  background: var(--surface2);
  border: 1px solid var(--border);
  border-radius: var(--radius);
  color: var(--cyan);
  font-family: var(--font-mono);
  font-size: 10.5px;
  padding: 2px 22px 2px 7px;
  cursor: pointer;
  outline: none;
  transition: border-color .15s;
  appearance: none;
  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='6' viewBox='0 0 10 6'%3E%3Cpath fill='%236272a4' d='M0 0l5 6 5-6z'/%3E%3C/svg%3E");
  background-repeat: no-repeat;
  background-position: right 6px center;
}
.model-select-native:hover,
.model-select-native:focus { border-color: var(--purple); }
.model-select-native option { background: var(--surface); }

.bar-btn {
  font-family: var(--font-mono);
  font-size: 10.5px;
  padding: 3px 9px;
  border-radius: var(--radius);
  border: 1px solid;
  cursor: pointer;
  transition: background .15s, color .15s, box-shadow .15s;
  letter-spacing: 0.04em;
  font-weight: 500;
}

.new-session-btn {
  color: var(--green);
  border-color: var(--green);
  background: transparent;
}
.new-session-btn:hover {
  background: rgba(80,250,123,0.12);
  box-shadow: 0 0 8px var(--green-glow);
}

.wipe-workspace-btn {
  color: var(--red);
  border-color: var(--red);
  background: transparent;
}
.wipe-workspace-btn:hover {
  background: rgba(255,85,85,0.12);
  box-shadow: 0 0 8px rgba(255,85,85,0.3);
}

/* ─── STATUS BAR ──────────────────────────────────────────────── */
#statusBar {
  display: flex;
  align-items: center;
  gap: 14px;
  padding: 3px 14px;
  background: var(--bg-darker);
  border-bottom: 1px solid var(--border);
  flex-shrink: 0;
  font-size: 10px;
  color: var(--comment);
  letter-spacing: 0.04em;
}

.status-dot {
  width: 6px; height: 6px;
  border-radius: 50%;
  display: inline-block;
  margin-right: 4px;
}
.status-dot.online  { background: var(--green); box-shadow: 0 0 5px var(--green); animation: pulse-green 2s infinite; }
.status-dot.offline { background: var(--red); }

@keyframes pulse-green {
  0%,100% { opacity: 1; }
  50%      { opacity: 0.4; }
}

.status-item { display: flex; align-items: center; }
.status-sep { color: var(--border); }
#mcpStatus { color: var(--green); }
#mcpStatus.offline { color: var(--red); }

/* ─── LOG / OUTPUT AREA ───────────────────────────────────────── */
#log {
  flex: 1;
  overflow-y: auto;
  padding: 14px 18px;
  background: var(--bg);
  scroll-behavior: smooth;
}

#log::-webkit-scrollbar { width: 6px; }
#log::-webkit-scrollbar-track { background: transparent; }
#log::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; }
#log::-webkit-scrollbar-thumb:hover { background: var(--comment); }

/* ─── LOG LINE TYPES ──────────────────────────────────────────── */
.line {
  display: block;
  padding: 1.5px 0;
  white-space: pre-wrap;
  word-break: break-word;
  animation: fadein .12s ease-out;
}

@keyframes fadein {
  from { opacity: 0; transform: translateY(2px); }
  to   { opacity: 1; transform: none; }
}

.line.user {
  color: var(--green);
  font-weight: 500;
}

.line.ai {
  color: var(--fg);
  padding-left: 0;
  position: relative;
}

.line.ai span {
  color: var(--purple);
  font-weight: 600;
}

.line.sys {
  color: var(--comment);
  font-size: 11.5px;
  font-style: italic;
}

.line.err {
  color: var(--red);
  font-weight: 600;
}

.line.tool {
  color: var(--orange);
  border-left: 2px solid var(--orange);
  padding-left: 10px;
  margin: 2px 0;
  background: rgba(255,184,108,0.04);
  border-radius: 0 var(--radius) var(--radius) 0;
}

/* welcome banner */
.banner-line {
  color: var(--pink);
  font-size: 11px;
  letter-spacing: 0.08em;
}

/* ─── DIVIDER ─────────────────────────────────────────────────── */
.log-divider {
  border: none;
  border-top: 1px solid var(--surface2);
  margin: 8px 0;
}

/* ─── INPUT ROW ───────────────────────────────────────────────── */
#inputRow {
  display: flex;
  align-items: center;
  gap: 0;
  padding: 8px 14px 10px;
  background: var(--bg-dark);
  border-top: 1px solid var(--border);
  flex-shrink: 0;
}

#terminalPrompt {
  color: var(--green);
  font-weight: 600;
  font-size: 13px;
  white-space: nowrap;
  margin-right: 8px;
  flex-shrink: 0;
  text-shadow: 0 0 8px var(--green-glow);
}

#input {
  flex: 1;
  background: transparent;
  border: none;
  outline: none;
  color: var(--fg);
  font-family: var(--font-mono);
  font-size: 13px;
  caret-color: var(--purple);
}

#input::placeholder { color: var(--border); }

.input-cursor-hint {
  width: 8px; height: 15px;
  background: var(--purple);
  animation: blink .9s step-start infinite;
  border-radius: 1px;
  flex-shrink: 0;
  opacity: 0.7;
}

@keyframes blink {
  50% { opacity: 0; }
}

/* ─── THINKING INDICATOR ──────────────────────────────────────── */
.thinking-dots {
  display: inline-flex;
  gap: 3px;
  margin-left: 6px;
  vertical-align: middle;
}
.thinking-dots span {
  width: 4px; height: 4px;
  background: var(--purple);
  border-radius: 50%;
  animation: bounce .8s ease-in-out infinite;
}
.thinking-dots span:nth-child(2) { animation-delay: .15s; }
.thinking-dots span:nth-child(3) { animation-delay: .30s; }

@keyframes bounce {
  0%,100% { transform: translateY(0); opacity: .4; }
  50%      { transform: translateY(-4px); opacity: 1; }
}

/* ─── SCROLLBAR ───────────────────────────────────────────────── */
* { scrollbar-width: thin; scrollbar-color: var(--border) transparent; }

/* ─── GLOW FOCUS INPUT ROW ────────────────────────────────────── */
#inputRow:focus-within {
  border-top-color: var(--purple);
  box-shadow: 0 -1px 0 0 var(--accent-glow);
}

/* ─── STOP BUTTON ─────────────────────────────────────────────── */
#stopBtn {
  display: none;
  align-items: center;
  gap: 5px;
  font-family: var(--font-mono);
  font-size: 11px;
  font-weight: 600;
  padding: 3px 10px;
  border-radius: var(--radius);
  border: 1px solid var(--red);
  color: var(--red);
  background: rgba(255,85,85,0.08);
  cursor: pointer;
  letter-spacing: 0.06em;
  transition: background .15s, box-shadow .15s;
  flex-shrink: 0;
  animation: fadein .15s ease-out;
}
#stopBtn:hover {
  background: rgba(255,85,85,0.18);
  box-shadow: 0 0 10px rgba(255,85,85,0.35);
}
#stopBtn.visible { display: inline-flex; }

.stop-icon {
  width: 8px; height: 8px;
  background: var(--red);
  border-radius: 1px;
  flex-shrink: 0;
}

/* ─── COLLAPSIBLE TOOL BLOCK ──────────────────────────────────── */
.tool-block {
  margin: 4px 0;
  border-left: 2px solid var(--orange);
  border-radius: 0 var(--radius) var(--radius) 0;
  background: rgba(255,184,108,0.04);
  overflow: hidden;
  animation: fadein .12s ease-out;
}

.tool-block-header {
  display: flex;
  align-items: center;
  gap: 8px;
  padding: 5px 10px;
  cursor: pointer;
  color: var(--orange);
  font-size: 12px;
  font-weight: 500;
  user-select: none;
  transition: background .12s;
}
.tool-block-header:hover { background: rgba(255,184,108,0.08); }

.tool-chevron {
  font-size: 9px;
  transition: transform .2s;
  opacity: 0.7;
  flex-shrink: 0;
}
.tool-block.open .tool-chevron { transform: rotate(90deg); }

.tool-block-label { flex: 1; }

.tool-block-badge {
  font-size: 9px;
  padding: 1px 6px;
  border-radius: 8px;
  border: 1px solid var(--orange);
  color: var(--orange);
  opacity: 0.6;
  flex-shrink: 0;
}
.tool-block.tool-error .tool-block-badge { border-color: var(--red); color: var(--red); }

.tool-block-body {
  display: none;
  padding: 0 10px 8px 10px;
  border-top: 1px solid rgba(255,184,108,0.12);
}
.tool-block.open .tool-block-body { display: block; }

.tool-block-section {
  margin-top: 6px;
}
.tool-block-section-label {
  font-size: 9px;
  color: var(--comment);
  letter-spacing: 0.1em;
  text-transform: uppercase;
  margin-bottom: 3px;
}
.tool-block-code {
  background: var(--bg-darker);
  border: 1px solid var(--border);
  border-radius: var(--radius);
  padding: 6px 8px;
  font-size: 11px;
  color: var(--cyan);
  white-space: pre-wrap;
  word-break: break-all;
  max-height: 180px;
  overflow-y: auto;
  line-height: 1.5;
}
.tool-block-code.result-text { color: var(--fg-dim); }
.tool-block.tool-error .tool-block-code.result-text { color: var(--red); }

/* history hint in input row */
.hist-hint {
  font-size: 9.5px;
  color: var(--border);
  flex-shrink: 0;
  padding-right: 4px;
  white-space: nowrap;
  transition: color .15s;
}
#inputRow:focus-within .hist-hint { color: var(--comment); }

/* ─── RESPONSIVE ──────────────────────────────────────────────── */
@media (max-width: 600px) {
  #titleText { display: none; }
  .bar-actions-group { gap: 5px; }
  .hist-hint { display: none; }
}
</style>
</head>
<body>

<div id="app">

  <!-- Title Bar -->
  <div id="titleBar">
    <div class="traffic-lights">
      <div class="tl tl-red"    title="Close"></div>
      <div class="tl tl-yellow" title="Minimize"></div>
      <div class="tl tl-green"  title="Maximize"></div>
    </div>
    <span id="titleText">ollama-terminal — dracula edition</span>
    <span class="title-badge">MCP</span>
  </div>

  <!-- Session / Multiplexer Bar -->
  <div id="sessionBar"></div>

  <!-- Status Bar -->
  <div id="statusBar">
    <span class="status-item">
      <span class="status-dot offline" id="mcpDot"></span>
      <span id="mcpStatus" class="offline">MCP offline</span>
    </span>
    <span class="status-sep">│</span>
    <span class="status-item">model: <span id="statusModel" style="color:var(--cyan);margin-left:4px;">—</span></span>
    <span class="status-sep">│</span>
    <span class="status-item" id="toolCount" style="color:var(--orange);">0 tools</span>
    <span class="status-sep">│</span>
    <span class="status-item" id="msgCount" style="color:var(--comment);">0 msgs</span>
  </div>

  <!-- Output Log -->
  <div id="log"></div>

  <!-- Input Row -->
  <div id="inputRow">
    <span id="terminalPrompt">user@ollama:~$</span>
    <input id="input" type="text" autocomplete="off" spellcheck="false" placeholder="enter a prompt or /help…" />
    <span class="hist-hint" title="↑↓ history">↑↓</span>
    <span id="stopBtn" title="Stop generation (Esc)">
      <span class="stop-icon"></span>Stop
    </span>
    <div class="input-cursor-hint"></div>
  </div>

</div>

<script type="module">
import { get, set, del } from 'https://cdn.jsdelivr.net/npm/idb-keyval@6/+esm';

/* ──────────────────────────────────────────────────────────────
   DOM REFS
────────────────────────────────────────────────────────────── */
const log            = document.getElementById("log");
const input          = document.getElementById("input");
const sessionBar     = document.getElementById("sessionBar");
const terminalPrompt = document.getElementById("terminalPrompt");
const mcpDot         = document.getElementById("mcpDot");
const mcpStatusEl    = document.getElementById("mcpStatus");
const statusModelEl  = document.getElementById("statusModel");
const toolCountEl    = document.getElementById("toolCount");
const msgCountEl     = document.getElementById("msgCount");
const stopBtn        = document.getElementById("stopBtn");

/* ──────────────────────────────────────────────────────────────
   CONSTANTS
────────────────────────────────────────────────────────────── */
const OLLAMA_URL    = "http://localhost:11434/api/chat";
const MCP_SERVER_URL = "http://localhost:3000";
const REGISTRY_KEY   = "multiplexer_registry_config";
const SESSION_PREFIX = "multiplexer_session_";

const POPULAR_MODELS = [
  "gemma4:e4b",
  "gemma4:latest",
  "qwen2.5-coder:14b"
];

const SYSTEM_PROMPT = {
  role: "system",
  content: "You are a helpful local terminal intelligence agent. You have real-time access to advanced local host platform systems tools. Invoke them whenever required to answer questions accurately."
};

/* ──────────────────────────────────────────────────────────────
   STATE
────────────────────────────────────────────────────────────── */
let registry = { currentActiveId: null, activeModel: "gemma4:latest", list: [] };
let activeMessages       = [SYSTEM_PROMPT];
let fullPersistentHistory = [];
let RUNTIME_AVAILABLE_TOOLS = [];

// ── Command History ──────────────────────────────────────────────
const CMD_HISTORY_MAX = 50;
let cmdHistory    = [];   // array of strings, oldest→newest
let historyIndex  = -1;   // -1 = not browsing; 0 = oldest
let historyDraft  = "";   // saves current typed text while browsing

// ── Abort Controller ────────────────────────────────────────────
let currentAbortController = null;

function setGenerating(on) {
  if (on) {
    stopBtn.classList.add("visible");
    input.disabled = true;
    input.placeholder = "generating… (Esc to stop)";
  } else {
    stopBtn.classList.remove("visible");
    input.disabled = false;
    input.placeholder = "enter a prompt or /help…";
    input.focus();
    currentAbortController = null;
  }
}

/* ──────────────────────────────────────────────────────────────
   STATUS BAR HELPERS
────────────────────────────────────────────────────────────── */
function setMcpStatus(online, toolCount = 0) {
  if (online) {
    mcpDot.className = "status-dot online";
    mcpStatusEl.className = "";
    mcpStatusEl.style.color = "var(--green)";
    mcpStatusEl.textContent = "MCP online";
  } else {
    mcpDot.className = "status-dot offline";
    mcpStatusEl.className = "offline";
    mcpStatusEl.style.color = "var(--red)";
    mcpStatusEl.textContent = "MCP offline";
  }
  toolCountEl.textContent = `${toolCount} tool${toolCount !== 1 ? 's' : ''}`;
}

function updateStatusBar() {
  statusModelEl.textContent = registry.activeModel || "—";
  const userMsgs = activeMessages.filter(m => m.role === "user").length;
  msgCountEl.textContent = `${userMsgs} msg${userMsgs !== 1 ? 's' : ''}`;
}

/* ──────────────────────────────────────────────────────────────
   MCP CLIENT
────────────────────────────────────────────────────────────── */
async function fetchToolsFromMcpServer() {
  try {
    print(`connecting to MCP gateway at ${MCP_SERVER_URL}…`, "sys");
    const response = await fetch(MCP_SERVER_URL, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ jsonrpc: "2.0", method: "tools/list", params: {}, id: 1 })
    });
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    const data = await response.json();
    if (data.result?.tools) {
      RUNTIME_AVAILABLE_TOOLS = data.result.tools.map(t => ({
        type: "function",
        function: {
          name: t.name,
          description: t.description,
          parameters: {
            type: t.inputSchema?.type || "object",
            properties: t.inputSchema?.properties || {},
            required: t.inputSchema?.required || []
          }
        }
      }));
      setMcpStatus(true, RUNTIME_AVAILABLE_TOOLS.length);
      print(`🟢 MCP connected — ${RUNTIME_AVAILABLE_TOOLS.length} tools loaded`, "sys");
    }
  } catch (err) {
    setMcpStatus(false, 0);
    print(`🔴 MCP offline (${err.message}) — text-only mode`, "sys");
    RUNTIME_AVAILABLE_TOOLS = [];
  }
}

async function executeMcpToolCall(name, args) {
  try {
    const response = await fetch(MCP_SERVER_URL, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ jsonrpc: "2.0", method: "tools/call", params: { name, arguments: args }, id: Date.now() })
    });
    if (!response.ok) {
      const errData = await response.json().catch(() => ({}));
      throw new Error(errData.error?.message || `HTTP ${response.status}`);
    }
    const rpcResult = await response.json();
    if (rpcResult.error) throw new Error(rpcResult.error.message);
    const content = rpcResult.result;
    if (content?.content && Array.isArray(content.content)) {
      return content.content.filter(c => c.type === "text").map(c => c.text).join("\n") || "No output.";
    }
    return JSON.stringify(content);
  } catch (err) {
    return `Tool error: ${err.message}`;
  }
}

/* ──────────────────────────────────────────────────────────────
   CONTEXT PRUNING
────────────────────────────────────────────────────────────── */
function pruneActiveMemory() {
  const sys = activeMessages[0];
  let hist = activeMessages.slice(1);
  while (hist.length > 16) hist.shift();
  while (hist.length > 0 && (hist[0].role === "tool" || hist[0].content === "")) hist.shift();
  activeMessages = [sys, ...hist];
  updateStatusBar();
}

/* ──────────────────────────────────────────────────────────────
   PERSISTENCE
────────────────────────────────────────────────────────────── */
async function saveAllToBrowser() {
  try {
    await set(REGISTRY_KEY, registry);
    if (registry.currentActiveId) await set(SESSION_PREFIX + registry.currentActiveId, fullPersistentHistory);
  } catch (err) { console.error("Storage write error:", err); }
}

async function loadSessionData(sessionId) {
  try {
    const saved = await get(SESSION_PREFIX + sessionId);
    fullPersistentHistory = saved || [];
    activeMessages = [SYSTEM_PROMPT, ...fullPersistentHistory.filter(m => !m.isToolActivityLog)];
    pruneActiveMemory();
    renderTerminalScreen();
    renderTopMultiplexerBar();
  } catch (err) { print("DB error: " + err.message, "err"); }
}

/* ──────────────────────────────────────────────────────────────
   RENDERING
────────────────────────────────────────────────────────────── */
function renderTopMultiplexerBar() {
  sessionBar.innerHTML = "";

  registry.list.forEach((session, index) => {
    const wrapper = document.createElement("div");
    wrapper.className = "session-wrapper";

    const tab = document.createElement("span");
    const isActive = session.id === registry.currentActiveId;
    tab.className = `session-tab ${isActive ? 'active' : ''}`;
    tab.textContent = `${index}: ${session.name}`;

    tab.addEventListener("click", () => { if (!isActive) switchSession(index); });

    tab.addEventListener("dblclick", (e) => {
      e.stopPropagation();
      const editorInput = document.createElement("input");
      editorInput.type = "text";
      editorInput.className = "rename-input";
      editorInput.value = session.name;

      const finishRename = async () => {
        const fresh = editorInput.value.trim();
        if (fresh && fresh !== session.name) { session.name = fresh; await saveAllToBrowser(); renderTerminalScreen(); }
        renderTopMultiplexerBar();
      };

      editorInput.addEventListener("keydown", (ke) => {
        if (ke.key === "Enter") finishRename();
        if (ke.key === "Escape") renderTopMultiplexerBar();
      });
      editorInput.addEventListener("blur", finishRename);
      wrapper.replaceChild(editorInput, tab);
      editorInput.focus(); editorInput.select();
    });

    wrapper.appendChild(tab);

    const del = document.createElement("span");
    del.className = "delete-btn";
    del.textContent = "✕";
    del.title = "Delete session";
    del.addEventListener("click", (e) => { e.stopPropagation(); handleDeleteSessionConfirmation(index); });
    wrapper.appendChild(del);
    sessionBar.appendChild(wrapper);
  });

  // Right-side controls
  const actions = document.createElement("div");
  actions.className = "bar-actions-group";

  const modelWrap = document.createElement("div");
  modelWrap.className = "model-selector-wrapper";
  modelWrap.innerHTML = `<span>⚙ model:</span>`;

  const sel = document.createElement("select");
  sel.className = "model-select-native";
  const models = [...new Set([registry.activeModel, ...POPULAR_MODELS])];
  models.forEach(m => {
    const opt = document.createElement("option");
    opt.value = m; opt.textContent = m;
    if (m === registry.activeModel) opt.selected = true;
    sel.appendChild(opt);
  });
  sel.addEventListener("change", e => switchActiveModel(e.target.value));
  modelWrap.appendChild(sel);
  actions.appendChild(modelWrap);

  const newBtn = document.createElement("span");
  newBtn.className = "bar-btn new-session-btn";
  newBtn.textContent = "+ New";
  newBtn.title = "Create new session";
  newBtn.addEventListener("click", () => handleCreateSession());
  actions.appendChild(newBtn);

  const wipeBtn = document.createElement("span");
  wipeBtn.className = "bar-btn wipe-workspace-btn";
  wipeBtn.textContent = "Wipe All";
  wipeBtn.title = "Erase all sessions";
  wipeBtn.addEventListener("click", () => handleWipeAllSessionsConfirmation());
  actions.appendChild(wipeBtn);

  sessionBar.appendChild(actions);
  updateStatusBar();
}

function renderTerminalScreen() {
  log.innerHTML = "";
  const cur = registry.list.find(s => s.id === registry.currentActiveId);
  const name = cur ? cur.name : "none";
  terminalPrompt.textContent = `user@ollama:[${name}]~$`;

  if (!cur) {
    printBanner();
    print("No active session. Click '+ New' or type /new to begin.", "sys");
    return;
  }

  if (fullPersistentHistory.length === 0) {
    printBanner();
    print(`Session [${name}] ready — model: ${registry.activeModel}`, "sys");
    print("Type /help for available commands.", "sys");
    return;
  }

  // Replay history — group tool activity log pairs into collapsed blocks
  let i = 0;
  while (i < fullPersistentHistory.length) {
    const msg = fullPersistentHistory[i];

    if (msg.role === "user") {
      print(`user@ollama:[${name}]~$ ${msg.content}`, "user");
      i++; continue;
    }

    if (msg.role === "assistant" && !msg.isInternalToolCall && msg.content?.trim()) {
      print(`assistant: ${msg.content}`, "ai");
      i++; continue;
    }

    // Tool activity log pair: "🔧 executing" followed by "📦 result"
    if (msg.isToolActivityLog && msg.content?.startsWith("🔧")) {
      const execMsg   = msg.content;                          // "🔧 [MCP] executing → toolName"
      const resultMsg = fullPersistentHistory[i + 1];        // "📦 [MCP] result: ..."

      const tName   = execMsg.replace("🔧 [MCP] executing → ", "").trim();
      const outcome = resultMsg?.content?.replace(/^📦 \[MCP\] result: /, "") ?? "";
      const isError = outcome.startsWith("Tool error:");

      // Reconstruct collapsed tool block
      const block = document.createElement("div");
      block.className = "tool-block" + (isError ? " tool-error" : "");

      const header = document.createElement("div");
      header.className = "tool-block-header";
      header.innerHTML = `
        <span class="tool-chevron">▶</span>
        <span class="tool-block-label">🔧 ${tName}</span>
        <span class="tool-block-badge">${isError ? "error" : "done"}</span>`;
      block.appendChild(header);

      const body = document.createElement("div");
      body.className = "tool-block-body";
      body.innerHTML = `
        <div class="tool-block-section">
          <div class="tool-block-section-label">result</div>
          <div class="tool-block-code result-text${isError ? "" : ""}">${outcome}</div>
        </div>`;
      block.appendChild(body);
      header.addEventListener("click", () => block.classList.toggle("open"));
      if (isError) block.classList.add("open");
      log.appendChild(block);

      i += 2; // skip both the exec and result log entries
      // also skip the isInternalToolCall assistant entry that follows
      if (fullPersistentHistory[i]?.isInternalToolCall) i++;
      continue;
    }

    i++; // skip anything else (isInternalToolCall, blank, etc.)
  }
}

function printBanner() {
  const lines = [
    "╔══════════════════════════════════════════╗",
    "║   🧛  OLLAMA TERMINAL  ·  DRACULA       ║",
    "║       MCP-powered local AI multiplexer   ║",
    "╚══════════════════════════════════════════╝",
  ];
  lines.forEach(l => print(l, "banner-line"));
  const hr = document.createElement("hr");
  hr.className = "log-divider";
  log.appendChild(hr);
}

function print(text, cls = "sys") {
  const div = document.createElement("div");
  div.className = "line " + cls;
  div.textContent = text;
  log.appendChild(div);
  log.scrollTop = log.scrollHeight;
  return div;
}

/* ──────────────────────────────────────────────────────────────
   MULTIPLEXER OPERATIONS
────────────────────────────────────────────────────────────── */
async function switchActiveModel(name) {
  if (!name?.trim()) return;
  registry.activeModel = name.trim();
  await saveAllToBrowser();
  updateStatusBar();
  print(`⚙ Model switched → ${registry.activeModel}`, "sys");
  renderTopMultiplexerBar();
}

async function handleCreateSession(customName = null) {
  // 1. Flush the current session to IndexedDB BEFORE switching away
  if (registry.currentActiveId) {
    try {
      await set(SESSION_PREFIX + registry.currentActiveId, fullPersistentHistory);
    } catch (e) { console.error("Failed to save current session before switching:", e); }
  }

  // 2. Now create and switch to the new session
  const id   = "s_" + Date.now();
  const name = customName?.trim() || `session-${registry.list.length}`;
  registry.list.push({ id, name });
  registry.currentActiveId = id;
  fullPersistentHistory = [];
  activeMessages = [SYSTEM_PROMPT];
  await saveAllToBrowser();
  renderTopMultiplexerBar();
  renderTerminalScreen();
}

async function switchSession(index) {
  const t = registry.list[index];
  if (!t || t.id === registry.currentActiveId) return;

  // Flush current session first, then switch
  if (registry.currentActiveId) {
    try {
      await set(SESSION_PREFIX + registry.currentActiveId, fullPersistentHistory);
    } catch (e) { console.error("Failed to save session before switch:", e); }
  }

  registry.currentActiveId = t.id;
  await set(REGISTRY_KEY, registry);
  await loadSessionData(t.id);
}

async function handleDeleteSessionConfirmation(index) {
  const s = registry.list[index];
  if (!s) return;
  if (confirm(`Delete session "${s.name}"?`)) {
    await del(SESSION_PREFIX + s.id);
    registry.list.splice(index, 1);
    if (registry.currentActiveId === s.id) {
      if (registry.list.length > 0) {
        registry.currentActiveId = registry.list[Math.max(0, index - 1)].id;
        await set(REGISTRY_KEY, registry);
        await loadSessionData(registry.currentActiveId);
      } else {
        registry.currentActiveId = null;
        fullPersistentHistory = [];
        activeMessages = [SYSTEM_PROMPT];
        await set(REGISTRY_KEY, registry);
        renderTopMultiplexerBar();
        renderTerminalScreen();
      }
    } else {
      await set(REGISTRY_KEY, registry);
      renderTopMultiplexerBar();
    }
  }
}

async function handleWipeAllSessionsConfirmation() {
  if (prompt("Type WIPE to erase all sessions:") === "WIPE") {
    for (const s of registry.list) await del(SESSION_PREFIX + s.id);
    await del(REGISTRY_KEY);
    registry.list = [];
    registry.currentActiveId = null;
    fullPersistentHistory = [];
    activeMessages = [SYSTEM_PROMPT];
    await handleCreateSession("general");
  }
}

async function handleSlashCommand(raw) {
  const parts = raw.trim().split(" ");
  const cmd   = parts[0].toLowerCase();
  const args  = parts.slice(1).join(" ");

  if (cmd === "/new") {
    await handleCreateSession(args || null);
  } else if (cmd === "/clear") {
    log.innerHTML = "";
    printBanner();
  } else if (cmd === "/help") {
    const cmds = [
      ["  /new [name]", "create a new session tab"],
      ["  /clear",      "clear the terminal output"],
      ["  /help",       "show this help message"],
    ];
    const keys = [
      ["  ↑ / ↓",       "cycle through command history"],
      ["  Esc",         "stop current generation"],
      ["  Enter",       "send prompt"],
    ];
    print("── commands ──────────────────────────────────", "sys");
    cmds.forEach(([c, d]) => print(`${c.padEnd(18)} — ${d}`, "sys"));
    print("── keyboard shortcuts ────────────────────────", "sys");
    keys.forEach(([c, d]) => print(`${c.padEnd(18)} — ${d}`, "sys"));
    print("──────────────────────────────────────────────", "sys");
  } else {
    print(`unknown command: ${cmd}  (try /help)`, "err");
  }
}

/* ──────────────────────────────────────────────────────────────
   STREAM / AGENTIC CORE
────────────────────────────────────────────────────────────── */
async function callModel() {
  currentAbortController = new AbortController();
  const payload = { model: registry.activeModel, stream: true, messages: activeMessages };
  if (RUNTIME_AVAILABLE_TOOLS.length > 0) payload.tools = RUNTIME_AVAILABLE_TOOLS;
  return await fetch(OLLAMA_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload),
    signal: currentAbortController.signal
  });
}

async function askAI(promptText) {
  const cur   = registry.list.find(s => s.id === registry.currentActiveId);
  const label = cur ? cur.name : "~";

  print(`user@ollama:[${label}]~$ ${promptText}`, "user");
  const userMsg = { role: "user", content: promptText };
  activeMessages.push(userMsg);
  fullPersistentHistory.push(userMsg);
  updateStatusBar();
  setGenerating(true);

  let guard = 6;
  let isProcessing = true;
  let aborted = false;

  try {
    while (isProcessing && guard-- > 0) {

      // Show thinking indicator for this iteration
      const thinkLine = document.createElement("div");
      thinkLine.className = "line sys";
      thinkLine.innerHTML = `<span style="color:var(--purple)">assistant</span> is thinking<div class="thinking-dots"><span></span><span></span><span></span></div>`;
      log.appendChild(thinkLine);
      log.scrollTop = log.scrollHeight;

      let stream;
      try {
        stream = await callModel();
      } catch (fetchErr) {
        thinkLine.remove();
        if (fetchErr.name === "AbortError") { aborted = true; break; }
        throw fetchErr;
      }

      const reader  = stream.body.getReader();
      const decoder = new TextDecoder();

      let displayEl  = null;
      let textNode   = null;
      let buf        = "";
      let fullText   = "";
      let toolCalls  = [];

      // Remove think line as soon as first chunk arrives
      let thinkRemoved = false;
      const removeThink = () => { if (!thinkRemoved) { thinkLine.remove(); thinkRemoved = true; } };

      try {
        while (true) {
          const { value, done } = await reader.read();
          if (done) break;
          buf += decoder.decode(value, { stream: true });
          const lines = buf.split("\n");
          buf = lines.pop();

          for (const line of lines) {
            if (!line.trim()) continue;
            try {
              const json = JSON.parse(line);
              const msg  = json.message;
              if (msg?.tool_calls?.length) {
                removeThink();
                msg.tool_calls.forEach(c => toolCalls.push(c));
              } else if (msg?.content) {
                removeThink();
                fullText += msg.content;
                if (!displayEl) {
                  displayEl = document.createElement("div");
                  displayEl.className = "line ai";
                  displayEl.innerHTML = `<span>assistant: </span>`;
                  textNode = document.createTextNode("");
                  displayEl.appendChild(textNode);
                  log.appendChild(displayEl);
                }
                textNode.nodeValue += msg.content;
                log.scrollTop = log.scrollHeight;
              }
            } catch {}
          }
        }
      } catch (readErr) {
        removeThink();
        if (readErr.name === "AbortError") { aborted = true; break; }
        throw readErr;
      }

      removeThink(); // guarantee removal even on empty stream

      if (aborted) break;

      if (toolCalls.length > 0) {
        // Discard any streamed text that was just the raw tool-call JSON Ollama leaked
        if (displayEl) displayEl.remove();
        displayEl = null;
        fullText  = "";   // never save tool-call JSON as visible assistant content

        const tc     = toolCalls[0];
        const tName  = tc.function.name;
        const tArgs  = tc.function.arguments || {};

        // ── Collapsible tool block ──────────────────────────────
        const block = document.createElement("div");
        block.className = "tool-block";

        const header = document.createElement("div");
        header.className = "tool-block-header";
        header.innerHTML = `
          <span class="tool-chevron">▶</span>
          <span class="tool-block-label">🔧 ${tName}</span>
          <span class="tool-block-badge">executing…</span>`;
        block.appendChild(header);

        const body = document.createElement("div");
        body.className = "tool-block-body";

        // Args section
        const argsSection = document.createElement("div");
        argsSection.className = "tool-block-section";
        argsSection.innerHTML = `<div class="tool-block-section-label">arguments</div>
          <div class="tool-block-code">${JSON.stringify(tArgs, null, 2)}</div>`;
        body.appendChild(argsSection);

        // Result placeholder
        const resultSection = document.createElement("div");
        resultSection.className = "tool-block-section";
        resultSection.innerHTML = `<div class="tool-block-section-label">result</div>
          <div class="tool-block-code result-text" id="tool-result-${Date.now()}">running…</div>`;
        body.appendChild(resultSection);
        block.appendChild(body);
        log.appendChild(block);
        log.scrollTop = log.scrollHeight;

        // Toggle open/close
        header.addEventListener("click", () => block.classList.toggle("open"));

        // Persist to history (compact)
        const logMsg = `🔧 [MCP] executing → ${tName}`;
        fullPersistentHistory.push({ role: "system", content: logMsg, isToolActivityLog: true });
        fullPersistentHistory.push({ role: "assistant", content: JSON.stringify(tc), isInternalToolCall: true });

        const outcome = await executeMcpToolCall(tName, tArgs);
        const isError = outcome.startsWith("Tool error:");

        // Update block with result
        const resultCode = resultSection.querySelector(".result-text");
        resultCode.textContent = outcome;
        const badge = header.querySelector(".tool-block-badge");
        badge.textContent = isError ? "error" : "done";
        if (isError) block.classList.add("tool-error");
        // Auto-open on error, auto-collapse on success
        if (isError) block.classList.add("open");

        const resultMsg = `📦 [MCP] result: ${outcome.substring(0, 400)}${outcome.length > 400 ? '…' : ''}`;
        fullPersistentHistory.push({ role: "system", content: resultMsg, isToolActivityLog: true });

        activeMessages.push({ role: "assistant", content: fullText || "", tool_calls: toolCalls });
        activeMessages.push({ role: "tool", content: outcome });

      } else {
        isProcessing = false;
        const finalMsg = { role: "assistant", content: fullText };
        activeMessages.push(finalMsg);
        // Only persist messages that have visible text content
        if (fullText.trim()) {
          fullPersistentHistory.push(finalMsg);
        }
      }
    }

    if (aborted) {
      print("⚠ Generation stopped by user.", "sys");
    }

    await saveAllToBrowser();
    pruneActiveMemory();

  } catch (err) {
    print(`runtime error: ${err.message}`, "err");
  } finally {
    setGenerating(false);
  }
}

/* ──────────────────────────────────────────────────────────────
   STOP BUTTON
────────────────────────────────────────────────────────────── */
stopBtn.addEventListener("click", () => {
  if (currentAbortController) {
    currentAbortController.abort();
  }
});

/* ──────────────────────────────────────────────────────────────
   INPUT HANDLER  (command history + stop on Esc)
────────────────────────────────────────────────────────────── */
input.addEventListener("keydown", async (e) => {

  // ── Esc → stop generation ──────────────────────────────────
  if (e.key === "Escape") {
    if (currentAbortController) {
      currentAbortController.abort();
    }
    return;
  }

  // ── ↑ → older history ─────────────────────────────────────
  if (e.key === "ArrowUp") {
    e.preventDefault();
    if (cmdHistory.length === 0) return;
    if (historyIndex === -1) {
      historyDraft   = input.value;   // save current draft
      historyIndex   = cmdHistory.length - 1;
    } else if (historyIndex > 0) {
      historyIndex--;
    }
    input.value = cmdHistory[historyIndex];
    // move cursor to end
    requestAnimationFrame(() => { input.selectionStart = input.selectionEnd = input.value.length; });
    return;
  }

  // ── ↓ → newer history / back to draft ─────────────────────
  if (e.key === "ArrowDown") {
    e.preventDefault();
    if (historyIndex === -1) return;
    if (historyIndex < cmdHistory.length - 1) {
      historyIndex++;
      input.value = cmdHistory[historyIndex];
    } else {
      historyIndex = -1;
      input.value  = historyDraft;
    }
    requestAnimationFrame(() => { input.selectionStart = input.selectionEnd = input.value.length; });
    return;
  }

  // ── Any other key resets history browsing ─────────────────
  if (e.key !== "Enter") {
    if (historyIndex !== -1) {
      // user started editing a history entry — detach
      historyIndex = -1;
    }
    return;
  }

  // ── Enter → submit ─────────────────────────────────────────
  const value = input.value.trim();
  if (!value) return;
  input.value  = "";
  historyIndex = -1;
  historyDraft = "";

  // Push to history (dedupe consecutive identical entries)
  if (cmdHistory[cmdHistory.length - 1] !== value) {
    cmdHistory.push(value);
    if (cmdHistory.length > CMD_HISTORY_MAX) cmdHistory.shift();
  }

  if (value.startsWith("/")) {
    print(`client:[cmd]~$ ${value}`, "user");
    await handleSlashCommand(value);
  } else {
    if (!registry.currentActiveId) {
      print("No active session. Type /new to start one.", "err");
      return;
    }
    await askAI(value);
  }
});

/* ──────────────────────────────────────────────────────────────
   BOOT
────────────────────────────────────────────────────────────── */
async function boot() {
  try {
    const saved = await get(REGISTRY_KEY);
    if (saved?.list?.length) {
      registry = saved;
    } else {
      const id = "s_" + Date.now();
      registry.list.push({ id, name: "general" });
      registry.currentActiveId = id;
    }
  } catch {
    const id = "s_" + Date.now();
    registry.list.push({ id, name: "general" });
    registry.currentActiveId = id;
  }

  renderTopMultiplexerBar();
  await loadSessionData(registry.currentActiveId);
  updateStatusBar();
  await fetchToolsFromMcpServer();

  // Focus input
  input.focus();
}

boot();
</script>
</body>
</html>

A very basis chat app with Ollama

artydev — Fri, 22 May 2026 12:17:50 +0000

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8" />
  <title>Artydev Coding Terminal</title>

  <!-- External Stylesheets -->
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@webtui/css/dist/base.css">
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@webtui/theme-catppuccin/dist/catppuccin.css">

  <style>
    body {
      margin: 0;
      background: #0b0f14;
      font-family: monospace;
      height: 100vh;
      display: flex;
      flex-direction: column;
      overflow: hidden;
    }

    /* --- FILLED BLOCK ASCII HEADER (CENTERED) --- */
    .banner-header {
      background: #0e121a;
      border-bottom: 1px solid rgba(255, 255, 255, 0.04);
      padding: 14px 16px 10px 16px;
      user-select: none;
      display: flex;
      flex-direction: column;
      align-items: center; 
      text-align: center;
    }
    .ascii-title {
      margin: 0;
      font-family: monospace;
      white-space: pre;
      line-height: 1.1;
      font-size: 11px;
      color: #89b4fa; /* Catppuccin Blue */
      text-shadow: 0 0 10px rgba(137, 180, 250, 0.25);
    }
    .sub-tagline {
      margin-top: 6px;
      font-size: 11px;
      color: #585b70;
    }

    /* --- TMUX STYLE MULTIPLEXER BAR --- */
    .session-bar {
      background: #11151c;
      border-bottom: 1px solid rgba(255, 255, 255, 0.08);
      padding: 6px 12px;
      display: flex;
      gap: 15px;
      font-size: 13px;
      user-select: none;
      align-items: center;
      overflow-x: auto;
    }

    .session-wrapper {
      display: inline-flex;
      align-items: center;
      gap: 4px;
      color: #7f849c;
    }

    .session-tab {
      cursor: pointer;
      white-space: nowrap;
    }

    .session-tab.active {
      color: #a6e3a1; /* Catppuccin Green */
      font-weight: bold;
    }

    .session-tab.active::before { content: "["; color: #7aa2f7; }
    .session-tab.active::after { content: "]*"; color: #7aa2f7; }

    /* Inline Rename Editor Box Styling */
    .rename-input {
      background: #1e1e2e;
      border: 1px solid #7aa2f7;
      color: #a6e3a1;
      font-family: monospace;
      font-size: 13px;
      padding: 0 4px;
      width: 100px;
      outline: none;
    }

    /* Subtle Delete Action Elements */
    .delete-btn {
      color: #585b70;
      cursor: pointer;
      font-size: 11px;
      padding: 0 2px;
      transition: color 0.15s ease;
      display: none; 
    }
    .session-wrapper:hover .delete-btn {
      display: inline-block;
    }
    .delete-btn:hover {
      color: #f38ba8 !important; 
    }

    .bar-actions-group {
      margin-left: auto;
      display: flex;
      gap: 16px;
      align-items: center;
    }

    /* Unintrusive Model Selector UX */
    .model-selector-wrapper {
      display: flex;
      align-items: center;
      gap: 6px;
      color: #94e2d5; /* Teal styling */
      font-size: 12px;
    }
    .model-select-native {
      background: #1e1e2e;
      color: #94e2d5;
      border: 1px solid rgba(148, 226, 213, 0.2);
      font-family: monospace;
      font-size: 11px;
      padding: 2px 6px;
      border-radius: 3px;
      outline: none;
      cursor: pointer;
    }
    .model-select-native:focus {
      border-color: #94e2d5;
    }

    .new-session-btn {
      color: #f5c2e7;
      cursor: pointer;
      font-weight: bold;
      white-space: nowrap;
    }

    .wipe-workspace-btn {
      color: #f38ba8; /* Warning Red */
      cursor: pointer;
      font-weight: normal;
      white-space: nowrap;
      opacity: 0.6;
      transition: opacity 0.15s ease;
    }
    .wipe-workspace-btn:hover {
      opacity: 1;
      text-shadow: 0 0 8px rgba(243, 139, 168, 0.2);
    }

    /* --- PRIMARY TERMINAL AREA --- */
    .terminal {
      flex: 1;
      display: flex;
      flex-direction: column;
      padding: 16px;
      box-sizing: border-box;
      overflow: hidden;
    }

    #log {
      flex: 1;
      overflow-y: auto;
      padding-right: 8px;
    }

    .line {
      white-space: pre-wrap;
      margin: 2px 0;
    }

    .user { color: #a6e3a1; }
    .ai { color: #f9e2af; }
    .sys { color: #7aa2f7; }
    .err { color: #f38ba8; }
    .tool { color: #f5c2e7; }

    .input-row {
      display: flex;
      gap: 10px;
      align-items: center;
      border-top: 1px solid rgba(255,255,255,0.08);
      padding-top: 10px;
    }

    .prompt { color: #cdd6f4; white-space: nowrap; }

    #input {
      flex: 1;
      background: transparent;
      border: none;
      outline: none;
      color: #cdd6f4;
      font-size: 14px;
      font-family: monospace;
    }

    /* --- BOTTOM HELP LEGEND --- */
    .footer-help {
      background: #11151c;
      border-top: 1px solid rgba(255, 255, 255, 0.05);
      padding: 6px 12px;
      font-size: 11px;
      color: #585b70;
      display: flex;
      gap: 20px;
      overflow-x: auto;
      white-space: nowrap;
    }
    .footer-help span strong {
      color: #cdd6f4;
    }
  </style>
</head>

<body data-webtui-theme="catppuccin-mocha">

  <!-- Block Character Filled ASCII Header -->
  <div class="banner-header">
    <pre class="ascii-title">
 █████╗ ██████╗ ████████╗██╗   ██╗██████╗ ███████╗██╗   ██╗     ██████╗ ██████╗ ██████╗ ██╗███╗   ██╗ ██████╗ 
██╔══██╗██╔══██╗╚══██╔══╝╚██╗ ██╔╝██╔══██╗██╔════╝██║   ██║    ██╔════╝██╔═══██╗██╔══██╗██║████╗  ██║██╔════╝ 
███████║██████╔╝   ██║    ╚████╔╝ ██║  ██║█████╗  ██║   ██║    ██║     ██║   ██║██║  ██║██║██╔██╗ ██║██║  ███╗
██╔══██║██╔══██╗   ██║     ╚██╔╝  ██║  ██║██╔══╝  ╚██╗ ██╔╝    ██║     ██║   ██║██║  ██║██║██║╚██╗██║██║   ██║
██║  ██║██║  ██║   ██║      ██║   ██████╔╝███████╗ ╚████╔╝     ╚██████╗╚██████╔╝██████╔╝██║██║ ╚████║╚██████╔╝
╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝      ╚═╝   ╚═════╝ ╚══════╝  ╚═══╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚═╝╚═╝  ╚═══╝ ╚═════╝ </pre>
    <div class="sub-tagline">Local Agent Orchestration Terminal • Core Runtime: Qwen2.5 + Dynamic Toolkits</div>
  </div>

  <!-- Multiplexer Navigation Bar -->
  <div class="session-bar" id="sessionBar"></div>

  <!-- Primary Interface Window -->
  <div class="terminal">
    <div id="log"></div>

    <div class="input-row">
      <span class="prompt" id="terminalPrompt">user@qwen:[~]~$</span>
      <input id="input" autocomplete="off" autofocus placeholder="Type a message or /command..." />
    </div>
  </div>

  <!-- Footer Keyboard Legend -->
  <div class="footer-help">
    <span><strong>Double-Click Tab</strong> Rename</span>
    <span><strong>Hover + [x]</strong> Delete single</span>
    <span><strong>/model [name]</strong> Switch core model</span>
    <span><strong>[Wipe All]</strong> Factory reset data</span>
    <span><strong>/new [name]</strong> Create context</span>
    <span><strong>/clear</strong> Clear view</span>
  </div>

<script type="module">
import { get, set, del } from 'https://cdn.jsdelivr.net/npm/idb-keyval@6/+esm';

const log = document.getElementById("log");
const input = document.getElementById("input");
const sessionBar = document.getElementById("sessionBar");
const terminalPrompt = document.getElementById("terminalPrompt");

const OLLAMA_URL = "http://localhost:11434/api/chat";
const REGISTRY_KEY = "multiplexer_registry_config";
const SESSION_PREFIX = "multiplexer_session_";

// List of available target models on your Ollama layer
const POPULAR_MODELS = [
  "qwen2.5:7b",
  "qwen2.5:14b",
  "qwen2.5:latest",
  "llama3.1:latest",
  "mistral:latest",
  "phi3:latest"
];

/* ---------------------------
   MEMORY SYSTEM STRUCTURES
----------------------------*/
const SYSTEM_PROMPT = {
  role: "system",
  content: `You are a tool-using assistant.
When you need to use a tool to look up information or perform calculations, you MUST respond ONLY with a raw valid JSON object matching this schema:
{
  "tool": "tool_name",
  "arguments": { "key": "value" }
}

Do not include conversational text when calling a tool.
Otherwise, respond normally to the user in plain text.

Available tools:
- get_time: Returns the current date and time. No arguments needed.
- calc: Calculates a mathematical expression. Requires argument "expression" (string).`
};

let registry = {
  currentActiveId: null,
  activeModel: "qwen2.5:7b", // Default fallback model
  list: []
};

let activeMessages = [SYSTEM_PROMPT]; 
let fullPersistentHistory = [];       

/* ---------------------------
   CONTEXT PRUNING (Sliding Window)
----------------------------*/
function pruneActiveMemory() {
  const systemPrompt = activeMessages[0];
  let chatHistory = activeMessages.slice(1);
  const MAX_ACTIVE_ITEMS = 14; 

  if (chatHistory.length > MAX_ACTIVE_ITEMS) {
    chatHistory = chatHistory.slice(chatHistory.length - MAX_ACTIVE_ITEMS);
    if (chatHistory[0].role === "user" && chatHistory[0].content.startsWith("TOOL RESULT")) {
      chatHistory.shift(); 
    }
  }
  activeMessages = [systemPrompt, ...chatHistory];
}

/* ---------------------------
   PERSISTENCE LAYER (IndexedDB)
----------------------------*/
async function saveAllToBrowser() {
  try {
    await set(REGISTRY_KEY, registry);
    if (registry.currentActiveId) {
      await set(SESSION_PREFIX + registry.currentActiveId, fullPersistentHistory);
    }
  } catch (err) {
    console.error("Storage save operation encountered errors:", err);
  }
}

async function loadSessionData(sessionId) {
  try {
    const savedData = await get(SESSION_PREFIX + sessionId);
    fullPersistentHistory = savedData || [];

    activeMessages = [SYSTEM_PROMPT, ...fullPersistentHistory.filter(m => !m.isToolActivityLog)];
    pruneActiveMemory();

    renderTerminalScreen();
    renderTopMultiplexerBar();
  } catch (err) {
    print("Database retrieval block failure: " + err.message, "err");
  }
}

/* ---------------------------
   UI RENDERING MANAGERS
----------------------------*/
function renderTopMultiplexerBar() {
  sessionBar.innerHTML = "";

  registry.list.forEach((session, index) => {
    const wrapper = document.createElement("div");
    wrapper.className = "session-wrapper";

    const tab = document.createElement("span");
    const isActive = session.id === registry.currentActiveId;
    tab.className = `session-tab ${isActive ? 'active' : ''}`;
    tab.textContent = `${index}: ${session.name}`;

    tab.addEventListener("click", (e) => {
      if (!isActive && tab.tagName === 'SPAN') switchSession(index);
    });

    tab.addEventListener("dblclick", (e) => {
      e.stopPropagation();
      const editorInput = document.createElement("input");
      editorInput.type = "text";
      editorInput.className = "rename-input";
      editorInput.value = session.name;

      const finishRename = async () => {
        const freshName = editorInput.value.trim();
        if (freshName && freshName !== session.name) {
          session.name = freshName;
          await saveAllToBrowser();
          renderTerminalScreen();
        }
        renderTopMultiplexerBar();
      };

      editorInput.addEventListener("keydown", (ke) => {
        if (ke.key === "Enter") finishRename();
        if (ke.key === "Escape") renderTopMultiplexerBar();
      });

      editorInput.addEventListener("blur", finishRename);

      wrapper.replaceChild(editorInput, tab);
      editorInput.focus();
      editorInput.select();
    });

    wrapper.appendChild(tab);

    const delBtn = document.createElement("span");
    delBtn.className = "delete-btn";
    delBtn.textContent = "[x]";
    delBtn.title = "Delete Session";
    delBtn.addEventListener("click", (e) => {
      e.stopPropagation();
      handleDeleteSessionConfirmation(index);
    });
    wrapper.appendChild(delBtn);

    sessionBar.appendChild(wrapper);
  });

  const actionsGroup = document.createElement("div");
  actionsGroup.className = "bar-actions-group";

  // Unintrusive Model Selection Element
  const modelWrapper = document.createElement("div");
  modelWrapper.className = "model-selector-wrapper";
  modelWrapper.innerHTML = `<span>model:</span>`;

  const modelSelect = document.createElement("select");
  modelSelect.className = "model-select-native";

  // Make sure the active model is always in the list options
  const modelsToRender = [...new Set([registry.activeModel, ...POPULAR_MODELS])];
  modelsToRender.forEach(modelName => {
    const opt = document.createElement("option");
    opt.value = modelName;
    opt.textContent = modelName;
    if (modelName === registry.activeModel) opt.selected = true;
    modelSelect.appendChild(opt);
  });

  modelSelect.addEventListener("change", async (e) => {
    await switchActiveModel(e.target.value);
  });

  modelWrapper.appendChild(modelSelect);
  actionsGroup.appendChild(modelWrapper);

  const createBtn = document.createElement("span");
  createBtn.className = "new-session-btn";
  createBtn.textContent = "+ [New]";
  createBtn.addEventListener("click", () => handleCreateSession());
  actionsGroup.appendChild(createBtn);

  const wipeBtn = document.createElement("span");
  wipeBtn.className = "wipe-workspace-btn";
  wipeBtn.textContent = "[Wipe All]";
  wipeBtn.title = "Irreversibly delete all database history records";
  wipeBtn.addEventListener("click", () => handleWipeAllSessionsConfirmation());
  actionsGroup.appendChild(wipeBtn);

  sessionBar.appendChild(actionsGroup);
}

function renderTerminalScreen() {
  log.innerHTML = "";
  const currentSession = registry.list.find(s => s.id === registry.currentActiveId);
  const sessionName = currentSession ? currentSession.name : "none";

  terminalPrompt.textContent = `user@qwen:[${sessionName}]~$`;

  if (!currentSession) {
    print("No active environment available. Please click '+ [New]' or type /new.", "sys");
    return;
  }

  if (fullPersistentHistory.length === 0) {
    print(`Welcome to session [${sessionName}]. Current Core: ${registry.activeModel}. Type your message or run /help.`, "sys");
    return;
  }

  for (const msg of fullPersistentHistory) {
    if (msg.role === "user" && !msg.content.startsWith("TOOL RESULT")) {
      print(`user@qwen:[${sessionName}]~$ ${msg.content}`, "user");
    } else if (msg.role === "assistant") {
      if (!msg.content.trim().startsWith("{")) {
        print(msg.content, "ai");
      }
    } else if (msg.role === "system" && msg.isToolActivityLog) {
      print(msg.content, "tool");
    }
  }
}

function print(text, cls="sys") {
  const div = document.createElement("div");
  div.className = "line " + cls;
  div.textContent = text;
  log.appendChild(div);
  log.scrollTop = log.scrollHeight;
  return div;
}

/* ---------------------------
   MULTIPLEXER OPERATIONS
----------------------------*/
async function switchActiveModel(newModelName) {
  if (!newModelName || !newModelName.trim()) return;
  registry.activeModel = newModelName.trim();
  await saveAllToBrowser();
  print(`Engine target processing runtime hot-swapped to: ${registry.activeModel}`, "sys");
  renderTopMultiplexerBar();
}

async function handleCreateSession(customName = null) {
  const id = "s_" + Date.now();
  const name = customName ? customName.trim() : `session-${registry.list.length}`;

  registry.list.push({ id, name });
  registry.currentActiveId = id;

  fullPersistentHistory = [];
  activeMessages = [SYSTEM_PROMPT];

  await saveAllToBrowser();
  renderTopMultiplexerBar();
  renderTerminalScreen();
}

async function switchSession(index) {
  const target = registry.list[index];
  if (!target) {
    print(`Error: Session index context [${index}] not tracked inside current workspace registry profiles.`, "err");
    return;
  }
  registry.currentActiveId = target.id;
  await saveAllToBrowser();
  await loadSessionData(target.id);
}

async function handleDeleteSessionConfirmation(index) {
  const targetSession = registry.list[index];
  if (!targetSession) return;

  if (confirm(`Are you sure you want to permanently delete session "${targetSession.name}"?`)) {
    await del(SESSION_PREFIX + targetSession.id);
    registry.list.splice(index, 1);

    if (registry.currentActiveId === targetSession.id) {
      if (registry.list.length > 0) {
        const nextIndexFallback = Math.max(0, index - 1);
        registry.currentActiveId = registry.list[nextIndexFallback].id;
        await set(REGISTRY_KEY, registry);
        await loadSessionData(registry.currentActiveId);
      } else {
        registry.currentActiveId = null;
        fullPersistentHistory = [];
        activeMessages = [SYSTEM_PROMPT];
        await set(REGISTRY_KEY, registry);
        renderTopMultiplexerBar();
        renderTerminalScreen();
      }
    } else {
      await set(REGISTRY_KEY, registry);
      renderTopMultiplexerBar();
    }
    print(`Successfully removed terminal workspace tracking profile target container: [${targetSession.name}]`, "sys");
  }
}

async function handleWipeAllSessionsConfirmation() {
  const explicitPromptText = "⚠️ WARNING: This will permanently delete ALL sessions and history logs. This action cannot be undone.\n\nType 'WIPE' to confirm initialization:";
  const confirmationInput = prompt(explicitPromptText);

  if (confirmationInput === "WIPE") {
    print("Initiating full environment memory database purge...", "err");

    for (const session of registry.list) {
      await del(SESSION_PREFIX + session.id);
    }

    await del(REGISTRY_KEY);

    registry.list = [];
    registry.currentActiveId = null;
    registry.activeModel = "qwen2.5:7b";
    fullPersistentHistory = [];
    activeMessages = [SYSTEM_PROMPT];

    print("Database scrub complete. Re-initializing factory general configuration environments.", "sys");

    await handleCreateSession("general");
  } else {
    print("Workspace wipe sequence aborted by user action.", "sys");
  }
}

/* ---------------------------
   SLASH COMMAND INTERCEPTOR
----------------------------*/
async function handleSlashCommand(rawInput) {
  const parts = rawInput.trim().split(" ");
  const cmd = parts[0].toLowerCase();
  const args = parts.slice(1).join(" ");

  print(`user@qwen:[command]~$ ${rawInput}`, "user");

  switch (cmd) {
    case "/new":
      await handleCreateSession(args || null);
      break;

    case "/model":
      if (!args.trim()) {
        print(`Current active context orchestration engine model target: ${registry.activeModel}`, "sys");
        print(`Usage option: /model [ollama-model-tag] (e.g., /model llama3.1:latest)`, "sys");
      } else {
        await switchActiveModel(args);
      }
      break;

    case "/switch":
      const targetIndex = parseInt(args, 10);
      if (isNaN(targetIndex)) {
        print("Usage error syntax structural rule: /switch [numerical-index-id]", "err");
      } else {
        await switchSession(targetIndex);
      }
      break;

    case "/rename":
      if (!args.trim()) {
        print("Usage error syntax: /rename [new-session-tag-name]", "err");
      } else {
        const activeItem = registry.list.find(s => s.id === registry.currentActiveId);
        if (activeItem) {
          activeItem.name = args.trim();
          await saveAllToBrowser();
          renderTopMultiplexerBar();
          renderTerminalScreen();
        }
      }
      break;

    case "/delete":
      const delIdx = parseInt(args, 10);
      if (isNaN(delIdx)) {
        print("Usage error syntax: /delete [numerical-index-id]", "err");
      } else {
        await handleDeleteSessionConfirmation(delIdx);
      }
      break;

    case "/wipeall":
      await handleWipeAllSessionsConfirmation();
      break;

    case "/ls":
      print("--- Active Workspace Environments ---", "sys");
      registry.list.forEach((s, idx) => {
        const activeMarker = s.id === registry.currentActiveId ? " (active)" : "";
        print(`  [${idx}]: ${s.name}${activeMarker}`, "sys");
      });
      break;

    case "/clear":
      log.innerHTML = "";
      break;

    case "/help":
      print("Available workspace commands:", "sys");
      print("  /model [tag]    - Hot-swap core backend model parsing engine dynamically", "sys");
      print("  /new [name]     - Create a brand new independent conversation container", "sys");
      print("  /switch [index] - Hot-swap active screen output to alternate target history", "sys");
      print("  /rename [name]  - Changes character pointer tracking tag assigned to window row", "sys");
      print("  /delete [index] - Deletes and drops tracked IndexedDB context elements from storage", "sys");
      print("  /wipeall        - Destroys and cleans entire memory workspace databases", "sys");
      print("  /ls             - Lists out all tracking logs captured via IndexedDB system paths", "sys");
      print("  /clear          - Standard display layer terminal clear operation layout reset", "sys");
      break;

    default:
      print(`Unrecognized multiplexer control sequence pipeline call target '${cmd}'. Try calling /help.`, "err");
  }
}

/* ---------------------------
   LOCAL ENVIRONMENT TOOLS
----------------------------*/
function runTool(name, args) {
  if (name === "get_time") {
    return { time: new Date().toISOString() };
  }
  if (name === "calc") {
    try {
      const evaluate = new Function(`return (${args.expression})`);
      return { result: evaluate() };
    } catch {
      return { error: "invalid expression" };
    }
  }
  return { error: "unknown tool" };
}

function tryParseTool(text) {
  try {
    const obj = JSON.parse(text.trim());
    if (obj.tool && obj.arguments) return obj;
  } catch {}
  return null;
}

/* ---------------------------
   STREAM INTERFACE DRIVER
----------------------------*/
async function streamAI(res) {
  const div = print("", "ai");
  const reader = res.body.getReader();
  const decoder = new TextDecoder();

  let buffer = "";
  let fullText = "";

  while (true) {
    const { value, done } = await reader.read();
    if (done) break;

    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop();

    for (const line of lines) {
      if (!line.trim()) continue;

      try {
        const json = JSON.parse(line);
        const token = json.message?.content || "";

        div.textContent += token;
        fullText += token;
        log.scrollTop = log.scrollHeight;
      } catch {}
    }
  }
  return fullText;
}

async function callModel() {
  const res = await fetch(OLLAMA_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model: registry.activeModel, // Dynamically injection based on selection config
      stream: true,
      messages: activeMessages
    })
  });

  if (!res.ok || !res.body) throw new Error(`Ollama communication pipeline break during request using model ${registry.activeModel}`);
  return res;
}

/* ---------------------------
   AGENTIC EXECUTION RUNTIME ENGINE
----------------------------*/
async function askAI(prompt) {
  const currentSession = registry.list.find(s => s.id === registry.currentActiveId);
  const sessionLabel = currentSession ? currentSession.name : "~";

  print(`user@qwen:[${sessionLabel}]~$ ${prompt}`, "user");

  const userMsg = { role: "user", content: prompt };
  activeMessages.push(userMsg);
  fullPersistentHistory.push(userMsg);

  let isAgentProcessing = true;
  let executionDepthGuard = 5; 

  try {
    while (isAgentProcessing && executionDepthGuard > 0) {
      executionDepthGuard--;

      const responseStream = await callModel();
      const aiResponseText = await streamAI(responseStream);

      const assistantMsg = { role: "assistant", content: aiResponseText };
      activeMessages.push(assistantMsg);
      fullPersistentHistory.push(assistantMsg);

      const parsedToolRequest = tryParseTool(aiResponseText);

      if (parsedToolRequest) {
        const actionMessage = `🔧 Executing tool: ${parsedToolRequest.tool}...`;
        print(actionMessage, "tool");
        fullPersistentHistory.push({ role: "system", content: actionMessage, isToolActivityLog: true });

        const toolOutcome = runTool(parsedToolRequest.tool, parsedToolRequest.arguments);
        const outcomeString = `📦 Response: ${JSON.stringify(toolOutcome)}`;
        print(outcomeString, "tool");
        fullPersistentHistory.push({ role: "system", content: outcomeString, isToolActivityLog: true });

        const toolResultFeedback = {
          role: "user",
          content: `TOOL RESULT for '${parsedToolRequest.tool}': ${JSON.stringify(toolOutcome)}`
        };
        activeMessages.push(toolResultFeedback);
        fullPersistentHistory.push(toolResultFeedback);
      } else {
        isAgentProcessing = false;
      }
    }

    await saveAllToBrowser();
    pruneActiveMemory();

  } catch (err) {
    print("Error encountered inside tracking node loops: " + err.message, "err");
  }
}

/* ---------------------------
   DOM INTERFACES INTERCEPT
----------------------------*/
input.addEventListener("keydown", async (e) => {
  if (e.key === "Enter") {
    const value = input.value.trim();
    if (!value) return;

    input.value = "";

    if (value.startsWith("/")) {
      await handleSlashCommand(value);
    } else {
      if (!registry.currentActiveId) {
        print("No active environment available. Please execute '/new' command to spawn a session first.", "err");
        return;
      }
      await askAI(value);
    }
  }
});

/* ---------------------------
   SYSTEM ENTRY BOOT STRAPPER
----------------------------*/
async function boot() {
  try {
    const savedRegistry = await get(REGISTRY_KEY);
    if (savedRegistry && savedRegistry.list.length > 0) {
      registry = savedRegistry;
      // Ensure configuration object structure compatibility if updating from previous version
      if (!registry.activeModel) registry.activeModel = "qwen2.5:7b";
      renderTopMultiplexerBar();
      await loadSessionData(registry.currentActiveId);
    } else {
      await handleCreateSession("general");
    }
  } catch (e) {
    console.warn("Storage profile structure state clean initialization step required:", e);
    await handleCreateSession("general");
  }
}

boot();
</script>

</body>
</html>

Csharp

artydev — Sun, 22 Feb 2026 04:07:15 +0000

Great tips Thank you

artydev — Sun, 22 Feb 2026 04:05:12 +0000

I Built a Lightweight Rule Engine for JS, C#, and Dart — Here's How It Works

Berat ARPA ・ Feb 21

#opensource #javascript #csharp #webdev

COI Components

artydev — Wed, 28 Jan 2026 08:04:23 +0000

From official site :

Components

Components are the building blocks of Coi applications. This guide covers component syntax, state management, lifecycle, and communication patterns.

Basic Structure

Component names must start with an uppercase letter:

component Counter {
    mut int count = 0;

    def increment() : void {
        count += 1;
    }

    style {
        button { padding: 8px 16px; }
    }

    view {
        <div>
            <span>{count}</span>
            <button onclick={increment}>+</button>
        </div>
    }
}

State & Mutability

Mutability (`mut`) and Visibility (`pub`)

Coi uses two orthogonal modifiers:

mut: Makes a variable mutable (can be changed from inside the component)
pub: Makes a variable or method visible (can be accessed from outside the component)

Variables:

Syntax	Inside Component	Outside Component	Description
`int x`	Read Only	Hidden	Private constant
`mut int x`	Read/Write	Hidden	Private mutable state
`pub int x`	Read Only	Read Only	Public constant
`pub mut int x`	Read/Write	Read Only	Public state (read-only outside)

Methods:

Syntax	Inside Component	Outside Component	Description
`def method() : void`	Callable	Hidden	Private method
`pub def method() : void`	Callable	Callable	Public method

Important: You can never write to a component's member from outside. If you need to modify a child's state, use a setter method or reference parameters.

component Counter(pub mut int count = 0) {
    mut int internal = 0;      // Private, mutable
    pub int version = 1;       // Public, constant

    def helper() : void { }    // Private method (not accessible from outside)
    pub def reset() : void {   // Public method (accessible from outside)
        count = 0;
    }
}

// Usage
component App {
    mut Counter counter;

    view {
        <div>
            <span>{counter.count}</span>     // ✅ Can read public state
            <span>{counter.version}</span>   // ✅ Can read public constant
            <button onclick={counter.reset}>Reset</button>  // ✅ Can call public method
            // ❌ counter.internal - Error: private member
            // ❌ counter.helper() - Error: private method
        </div>
    }
}

Component Parameters

Components receive data through constructor-style parameters:

component Editor(
    string label,           // Value parameter (copied by default, can be moved with :)
    mut int& value,         // Reference parameter (two-way binding)
    int step = 1,           // Value parameter with default
    def onChange : void     // Function parameter (callback)
) {
    def increment() : void {
        value += step;
        onChange();
    }

    view {
        <button onclick={increment}>{label}</button>
    }
}

// Usage examples:
component App {
    mut string text = "Label";
    mut int count = 0;

    view {
        <div>
            // Default: copies text
            <Editor label={text} &value={count} &onChange={handleChange} />

            // Move: transfers ownership of text
            <Editor :label={text} &value={count} &onChange={handleChange} />
        </div>
    }
}

Parameter Passing Modes

Syntax	Mode	Usage in Call	Description
`Type name`	Value	`comp(value)` or `comp(:value)`	Copied by default, can be moved with `:`
`mut Type& name`	Reference	`comp(&value)`	Component can read/modify parent's state
`def name(args) : ret`	Callback	`comp(&callback)`	Function passed from parent

Reference Parameters (`&`)

Reference parameters allow child components to modify the parent's state directly:

// Declaration
component StepButton(mut int& count) {
    def add() : void {
        count += 1;  // Modifies parent's state
    }

    view {
        <button onclick={add}>+</button>
    }
}

// Usage
component App {
    mut int score = 0;

    view {
        <div>
            <span>{score}</span>
            <StepButton &count={score} />
        </div>
    }
}

Move Semantics (`:`)

Use : to transfer ownership of a value to the child component. The parent's variable becomes invalid after the move:

<Editor :content={document} />

In code, use := for move assignment:

string source = "Hello";
string dest := source;  // Move assignment
// source is now invalid

Function Parameters (`def`)

Pass callbacks to child components:

// Simple callback
component Button(string label, def onclick : void) {
    view {
        <button onclick={onclick}>{label}</button>
    }
}

// Typed callback with parameters
component ListItem(
    pub int id,
    def onRemove(int) : void
) {
    view {
        <button onclick={onRemove(id)}>Delete</button>
    }
}

// Usage
component App {
    def handleClick() : void {
        System.log("Clicked!");
    }

    def handleRemove(int itemId) : void {
        // Remove item with itemId
    }

    view {
        <div>
            <Button label="Click" &onclick={handleClick} />
            <ListItem id={1} &onRemove={handleRemove(id)} />
        </div>
    }
}

Component Lifecycle

┌─────────────────────────────────────────────────────────┐
│  1. init {}     - State initialization (no DOM yet)    │
│  2. view {}     - DOM elements are created             │
│  3. mount {}    - DOM is ready, elements accessible    │
│  4. tick(dt) {} - Called every frame (if defined)      │
└─────────────────────────────────────────────────────────┘

`init {}` — Pre-render Setup

Runs before the view is rendered. Use for state initialization:

component App {
    mut int[] data;
    mut string status;

    init {
        data = [1, 2, 3, 4, 5];
        status = "Ready";
        // ❌ Cannot access DOM elements here
    }
}

`mount {}` — Post-render Initialization

Runs after the view is rendered. Use when you need DOM access:

component CanvasApp {
    mut Canvas canvas;
    mut CanvasContext2D ctx;

    mount {
        // ✅ DOM is ready
        canvas.setSize(800, 600);
        ctx = canvas.getContext2d();
    }

    view {
        <canvas &={canvas}></canvas>
    }
}

`tick(float dt) {}` — Animation Loop

Called every frame. dt is delta time in seconds:

component AnimatedBall {
    mut float x = 0;
    mut float speed = 100;

    tick(float dt) {
        x += speed * dt;  // Move 100 pixels per second
        if (x > 400) x = 0;
    }

    view {
        <div style="left: {x}px;"></div>
    }
}

Lifecycle Summary

Block	When it runs	DOM available?	Use for
`init {}`	Before view	❌ No	State setup, calculations
`view {}`	Creates DOM	Being created	Define HTML structure
`mount {}`	After view	✅ Yes	Canvas setup, DOM measurements
`tick(dt) {}`	Every frame	✅ Yes	Animations, physics, updates

Logic-Only Components

Components don't require a view block:

component Timer {
    pub mut int elapsed = 0;
    pub mut bool running = false;

    tick(float dt) {
        if (running) {
            elapsed++;
        }
    }

    pub def start() : void { running = true; }
    pub def stop() : void { running = false; }
    pub def reset() : void { elapsed = 0; }
}

component App {
    mut Timer timer;

    view {
        <div>
            <span>Elapsed: {timer.elapsed}</span>
            <button onclick={timer.start}>Start</button>
        </div>
    }
}

Persisting Component State

Components inside <if> branches are destroyed when the condition changes. To persist state, declare as a member:

component App {
    mut bool showEditor = false;
    mut Editor editor;  // Persists across toggles

    view {
        <div>
            <button onclick={toggle}>Toggle</button>
            <if showEditor>
                <{editor} />  // Uses existing member
            </if>
        </div>
    }
}

Client-Side Routing

Coi has built-in client-side routing for single-page applications. Define routes with the router {} block and render the current route with <route />.

Basic Routing

import "pages/Home.coi";
import "pages/About.coi";
import "pages/Dashboard.coi";

component App {
    router {
        "/" => Home,
        "/about" => About,
        "/dashboard" => Dashboard
    }

    view {
        <div>
            <nav>
                <a href="/">Home</a>
                <a href="/about">About</a>
            </nav>
            <route />
        </div>
    }
}

Passing Props to Routes

Pass callbacks or values to route components:

component App {
    mut bool isLoggedIn = false;

    def handleLogin() : void {
        isLoggedIn = true;
    }

    def handleLogout() : void {
        isLoggedIn = false;
    }

    router {
        "/" => Landing(&handleLogin),
        "/dashboard" => Dashboard(&handleLogout)
    }

    view {
        <div>
            <NavBar />
            <route />
            <Footer />
        </div>
    }
}

Programmatic Navigation

Use System.navigate(path) to navigate programmatically:

component NavBar {
    def goToDashboard() : void {
        System.navigate("/dashboard");
    }

    def goToHome() : void {
        System.navigate("/");
    }

    view {
        <nav>
            <button onclick={goToHome}>Home</button>
            <button onclick={goToDashboard}>Dashboard</button>
        </nav>
    }
}

How It Works

Routes are defined in the router {} block with "path" => Component syntax
The <route /> element renders the component matching the current URL
System.navigate(path) changes the URL and updates the view
The router reads the initial URL on page load, so direct links work (e.g., /dashboard)
Browser back/forward buttons work automatically via the History API

Route Summary

Feature	Syntax	Description
Define routes	`router { "/" => Home }`	Map paths to components
Render route	`<route />`	Placeholder for current route's component
Navigate	`System.navigate("/path")`	Programmatically change route
With props	`"/" => Page(callback)`	Pass props to route component

Platform APIs

artydev — Wed, 28 Jan 2026 07:58:13 +0000

From official site:

Platform APIs

Coi provides type-safe access to browser APIs through the WebCC toolchain. These APIs are automatically generated from the WebCC schema.

Type System

All platform types use a consistent pattern:

type: Defines a handle type (like Canvas, Image, DOMElement)
shared def: Static/factory methods called on the type itself
def: Instance methods called on an instance

// Static method
Image photo = Image.load("photo.png");

// Instance method
canvas.setSize(800, 600);
ctx = canvas.getContext2d();

No-Copy Types

Platform types (handles to browser resources) cannot be copied - they can only be moved or referenced:

// ERROR: Cannot copy a Canvas
mut Canvas canvas1 = Canvas.createCanvas("c1", 800.0, 600.0);
mut Canvas canvas2 = canvas1;  // Error!

// OK: Move ownership
mut Canvas canvas1 = Canvas.createCanvas("c1", 800.0, 600.0);
mut Canvas canvas2 := canvas1;  // canvas1 is now invalid

// OK: Reference (borrow)
mut Canvas canvas1 = Canvas.createCanvas("c1", 800.0, 600.0);
mut Canvas& canvasRef = canvas1;  // Both valid (& is part of type, not value)

// OK: Fresh value from factory method
mut Canvas canvas = Canvas.createCanvas("c1", 800.0, 600.0);  // Not a copy

This applies to all platform types:

Canvas, CanvasContext2D
DOMElement, Image, Audio
WebSocket, FetchRequest
WebGLContext, WGPUContext, etc.

Arrays of these types also cannot be copied:

// ERROR: Cannot copy Audio[]
mut Audio[] sounds = [Audio.load("a.mp3"), Audio.load("b.mp3")];
mut Audio[] backup = sounds;  // Error!

// OK: Move the array
mut Audio[] backup := sounds;  // sounds is now invalid

Canvas

2D drawing, paths, text, images, and transformations.

Canvas Methods

Method	Description
`canvas.getContext2d()`	Get 2D rendering context
`canvas.setSize(width, height)`	Set canvas dimensions

CanvasContext2D Methods

Shapes

Method	Description
`fillRect(x, y, w, h)`	Fill a rectangle
`strokeRect(x, y, w, h)`	Stroke a rectangle outline
`clearRect(x, y, w, h)`	Clear a rectangular area

Paths

Method	Description
`beginPath()`	Start a new path
`closePath()`	Close the current path
`moveTo(x, y)`	Move to point
`lineTo(x, y)`	Draw line to point
`arc(x, y, radius, startAngle, endAngle)`	Draw an arc
`arcTo(x1, y1, x2, y2, radius)`	Draw arc between points
`bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y)`	Cubic bezier curve
`quadraticCurveTo(cpx, cpy, x, y)`	Quadratic bezier curve
`rect(x, y, w, h)`	Add rectangle to path
`ellipse(x, y, rx, ry, rotation, start, end, ccw)`	Draw ellipse
`fill()`	Fill the current path
`stroke()`	Stroke the current path
`clip()`	Clip to current path

Styles

Method	Description
`setFillStyle(r, g, b)`	Set fill color (RGB 0-255)
`setFillStyleStr(color)`	Set fill color (CSS string)
`setStrokeStyle(r, g, b)`	Set stroke color (RGB 0-255)
`setStrokeStyleStr(color)`	Set stroke color (CSS string)
`setLineWidth(width)`	Set line width
`setLineCap(cap)`	Set line cap ("butt", "round", "square")
`setLineJoin(join)`	Set line join ("miter", "round", "bevel")
`setGlobalAlpha(alpha)`	Set global transparency (0.0-1.0)
`setShadow(blur, offX, offY, color)`	Set shadow effect

Text

Method	Description
`setFont(font)`	Set font (e.g., "16px Arial")
`setTextAlign(align)`	Set alignment ("left", "center", "right")
`setTextBaseline(baseline)`	Set baseline ("top", "middle", "bottom")
`fillText(text, x, y)`	Draw filled text
`strokeText(text, x, y)`	Draw stroked text
`measureTextWidth(text)`	Get text width in pixels

Images

Method	Description
`drawImage(image, x, y)`	Draw image at position
`drawImageScaled(image, x, y, w, h)`	Draw image scaled
`drawImageFull(img, sx, sy, sw, sh, dx, dy, dw, dh)`	Draw image with source rect

Transforms

Method	Description
`save()`	Save current state
`restore()`	Restore saved state
`translate(x, y)`	Move origin
`rotate(angle)`	Rotate (radians)
`scale(x, y)`	Scale
`setTransform(a, b, c, d, e, f)`	Set transform matrix
`resetTransform()`	Reset to identity

Setup Example

[!IMPORTANT]
Upcoming Change: Canvas.createCanvas() will be removed in a future release. Use <canvas &={canvas}> in your view instead. See CHANGES.md for migration details.

component CanvasApp {
    mut Canvas canvas;
    mut CanvasContext2D ctx;

    mount {
        canvas.setSize(800, 600);
        ctx = canvas.getContext2d();
    }

    view {
        <canvas &={canvas}></canvas>
    }
}

Example: Bouncing Ball

component AnimatedBall {
    mut Canvas canvas;
    mut CanvasContext2D ctx;
    mut float x = 100.0;
    mut float y = 100.0;
    mut float dx = 3.0;
    mut float dy = 2.0;

    mount {
        canvas.setSize(800, 600);
        ctx = canvas.getContext2d();
    }

    tick(float dt) {
        ctx.clearRect(0, 0, 800, 600);
        ctx.setFillStyle(66, 133, 244);
        ctx.beginPath();
        ctx.arc(x, y, 20, 0, 6.28318);
        ctx.fill();

        x += dx;
        y += dy;
        if (x < 20 || x > 780) dx = -dx;
        if (y < 20 || y > 580) dy = -dy;
    }

    view {
        <canvas &={canvas}></canvas>
    }
}

Image

Load images for canvas rendering.

Methods

Method	Description
`Image.load(string src)`	Load image from URL (static)

Example

component Gallery {
    mut Canvas canvas;
    mut CanvasContext2D ctx;
    Image photo;

    mount {
        canvas.setSize(400, 300);
        ctx = canvas.getContext2d();
        photo = Image.load("photo.png");
    }

    def draw() : void {
        ctx.drawImage(photo, 0, 0);
    }

    view {
        <div>
            <canvas &={canvas}></canvas>
            <button onclick={draw}>Draw</button>
        </div>
    }
}

Storage

Local storage for persisting data.

Methods

Method	Description
`Storage.setItem(string key, string value)`	Store a key-value pair
`Storage.removeItem(string key)`	Remove item by key
`Storage.clear()`	Clear all stored items

Example

component Settings {
    mut string theme = "light";

    def saveTheme() : void {
        Storage.setItem("theme", theme);
    }

    def toggleTheme() : void {
        theme = theme == "light" ? "dark" : "light";
        saveTheme();
    }

    view {
        <button onclick={toggleTheme}>Theme: {theme}</button>
    }
}

Audio

Audio playback with volume, looping, and playback position.

Methods

Method	Description
`Audio.load(string src)`	Create audio from URL (static)
`play()`	Start playback
`pause()`	Pause playback
`setVolume(float vol)`	Set volume (0.0 to 1.0)
`setLoop(int loop)`	Enable/disable looping (1/0)
`getCurrentTime()`	Get current playback position (seconds)
`getDuration()`	Get total duration (seconds)

Example

component MusicPlayer {
    mut Audio music;
    mut bool playing = false;
    mut float progress = 0;

    mount {
        music = Audio.load("song.mp3");
        music.setVolume(0.8);
    }

    tick(float dt) {
        if (playing) {
            float duration = music.getDuration();
            if (duration > 0) {
                progress = (music.getCurrentTime() / duration) * 100;
            }
        }
    }

    def toggle() : void {
        if (playing) {
            music.pause();
        } else {
            music.play();
        }
        playing = !playing;
    }

    view {
        <div>
            <button onclick={toggle}>
                {playing ? "Pause" : "Play"}
            </button>
            <div style="width: {progress}%"></div>
        </div>
    }
}

System

Logging, page title, time, random numbers, and URL navigation.

Methods

Method	Description
`System.log(string msg)`	Log message to console
`System.warn(string msg)`	Log warning to console
`System.error(string msg)`	Log error to console
`System.setTitle(string title)`	Set page title
`System.reload()`	Reload the page
`System.openUrl(string url)`	Open URL in new tab
`System.navigate(string path)`	Navigate to route (client-side routing)
`System.getTime()`	Get time in seconds (float64)
`System.getDateNow()`	Get milliseconds since epoch (float64)
`System.random()`	Random float between 0.0 and 1.0
`System.random(int seed)`	Seeded random (for reproducibility)

Example

// Logging
System.log("Debug message");
System.warn("Warning!");
System.error("Error occurred");

// Page title
System.setTitle("My App");

// Time
float now = System.getTime();       // Seconds (high precision)
float epoch = System.getDateNow();  // Milliseconds since epoch

// Random numbers
float r = System.random();          // 0.0 to 1.0

// URL navigation
System.openUrl("https://example.com");  // Opens in new tab
System.navigate("/dashboard");           // Client-side navigation

Input

Keyboard input handling.

Methods

Method	Description
`Input.isKeyDown(int keyCode)`	Check if key is currently pressed
`Input.isKeyUp(int keyCode)`	Check if key is currently released
`Input.exitPointerLock()`	Exit pointer lock mode

Common Key Codes

Key	Code
Left Arrow	37
Up Arrow	38
Right Arrow	39
Down Arrow	40
Space	32
Enter	13
Escape	27
W/A/S/D	87/65/83/68

Example

component Game {
    mut Canvas canvas;
    mut CanvasContext2D ctx;

    mut float x = 400;
    mut float y = 300;
    mut float speed = 300;

    float width = 800;
    float height = 600;
    float radius = 20;

    mount {
        canvas.setSize(width, height);
        ctx = canvas.getContext2d();
    }

    tick(float dt) {
        // Movement
        if (Input.isKeyDown(37)) x -= speed * dt;  // Left
        if (Input.isKeyDown(39)) x += speed * dt;  // Right
        if (Input.isKeyDown(38)) y -= speed * dt;  // Up
        if (Input.isKeyDown(40)) y += speed * dt;  // Down

        ctx.clearRect(0, 0, width, height);

        // Background
        ctx.setFillStyleStr("#1a1a1a");
        ctx.fillRect(0, 0, 800, 600);
        // Player
        ctx.beginPath();
        ctx.arc(x, y, radius, 0, 6.28);
        ctx.setFillStyleStr("#4ade80");
        ctx.fill();
    }


    view {
            <canvas &={canvas}></canvas>
    }
}

DOMElement

Direct DOM manipulation for browser APIs and measurements.

[!IMPORTANT]
Upcoming Change: Direct DOM manipulation (.appendChild(), .setInnerHtml(), .addClass()) will be discouraged in favor of declarative view syntax in future releases. DOMElement references should primarily be used for browser APIs like requestFullscreen() or measurements. See CHANGES.md for details.

Methods

Method	Description
`DOMElement.getBody()`	Get document body (static)
`DOMElement.getElementById(string id)`	Get element by ID (static)
`DOMElement.createElement(string tag)`	Create new element (static)
`setAttribute(string name, string value)`	Set attribute
`getAttribute(string name)`	Get attribute value
`appendChild(DOMElement child)`	Append child element
`insertBefore(DOMElement child, DOMElement ref)`	Insert before reference
`removeElement()`	Remove this element
`setInnerHtml(string html)`	Set inner HTML
`setInnerText(string text)`	Set inner text
`addClass(string cls)`	Add CSS class
`removeClass(string cls)`	Remove CSS class
`requestFullscreen()`	Enter fullscreen mode
`requestPointerLock()`	Request pointer lock

Example

component App {
    mut DOMElement container;

    mount {
        DOMElement div = DOMElement.createElement("div");
        div.setInnerHtml("<p>Dynamic content</p>");
        div.addClass("dynamic");
        container.appendChild(div);
    }

    view {
        <div &={container}></div>
    }
}

Fetch

HTTP requests with callback-based response handling. Returns a FetchRequest handle.

Methods

Method	Description
`FetchRequest.get(url, &onSuccess=..., &onError=...)`	Make a GET request (static)
`FetchRequest.post(url, body, &onSuccess=..., &onError=...)`	Make a POST request (static)

Callback Signatures

Callback	Signature	Description
`onSuccess`	`def handler(string data) : void`	Called with response data
`onError`	`def handler(string error) : void`	Called on request error

Example

component DataLoader {
    mut string result = "Click to load data";
    mut bool loading = false;

    def handleSuccess(string data) : void {
        loading = false;
        result = data;
    }

    def handleError(string error) : void {
        loading = false;
        result = "Error: " + error;
    }

    def loadData() : void {
        loading = true;
        result = "Loading...";
        FetchRequest.get(
            "https://api.example.com/data",
            &onSuccess = handleSuccess,
            &onError = handleError
        );
    }

    view {
        <div>
            <button onclick={loadData}>Load</button>
            <p>{result}</p>
        </div>
    }
}

POST Example

component FormSubmit {
    mut string status = "";

    def handleSuccess(string response) : void {
        status = "Submitted!";
    }

    def handleError(string error) : void {
        status = "Failed: " + error;
    }

    def submit() : void {
        status = "Submitting...";
        FetchRequest.post(
            "https://api.example.com/submit",
            "{\"name\": \"test\"}",
            &onSuccess = handleSuccess,
            &onError = handleError
        );
    }

    view {
        <div>
            <button onclick={submit}>Submit</button>
            <p>{status}</p>
        </div>
    }
}

JSON

Type-safe JSON parsing with compile-time schema validation and presence tracking.

Methods

Method	Description
`Json.parse(Type, json, &onSuccess=..., &onError=...)`	Parse JSON into a data type (static)
`Json.stringify(value)`	Convert data type to JSON string (static)

Defining Data Types

JSON parsing requires a data definition that describes the expected structure:

data Address {
    string street;
    string city;
    int zipcode;
}

data User {
    string name;
    int age;
    string email;
    Address address;      // Nested objects
    string[] tags;        // Arrays
    Friend[] friends;     // Arrays of objects
}

Callback Signatures

Callback	Signature	Description
`onSuccess`	`def handler(Type data, TypeMeta meta) : void`	Called with parsed data and presence info
`onError`	`def handler(string error) : void`	Called when JSON structure is malformed

Note: onError is only called for invalid JSON structure (unbalanced braces, unclosed strings, etc.). Missing fields or type mismatches don't trigger errors - instead, those fields simply won't be marked as present in the meta struct.

Meta Structs (Presence Checking)

The onSuccess callback receives a meta data that tracks which fields were present in the JSON. This handles optional/nullable fields gracefully:

def handleUser(User u, UserMeta meta) : void {
    // Check if fields were present in JSON
    if (meta.has_name()) {
        System.log("Name: " + u.name);
    }

    if (meta.has_age()) {
        System.log("Age: {u.age}");
    }

    // Nested objects have nested meta
    if (meta.has_address()) {
        if (meta.address.has_city()) {
            System.log("City: " + u.address.city);
        }
    }
}

Example: Fetch + Parse

component UserLoader {
    mut string status = "Ready";
    mut User user;

    def handleSuccess(string data) : void {
        Json.parse(
            User,
            data,
            &onSuccess = handleParsedUser,
            &onError = handleParseError
        );
    }

    def handleParsedUser(User u, UserMeta meta) : void {
        user = u;
        status = "Loaded: " + u.name;
    }

    def handleParseError(string error) : void {
        status = "Parse error: " + error;
    }

    def handleFetchError(string error) : void {
        status = "Fetch error: " + error;
    }

    def loadUser() : void {
        status = "Loading...";
        FetchRequest.get(
            "https://api.example.com/user/1",
            &onSuccess = handleSuccess,
            &onError = handleFetchError
        );
    }

    view {
        <div>
            <button onclick={loadUser}>Load User</button>
            <p>{status}</p>
        </div>
    }
}

Supported Types

Type	JSON	Notes
`string`	`"text"`	Handles escape sequences
`int`	`123`	32-bit signed integer
`float`	`3.14`	64-bit double
`bool`	`true`/`false`
`Type`	`{...}`	Nested data types
`string[]`	`[...]`	Array of strings
`int[]`	`[...]`	Array of integers
`Type[]`	`[...]`	Array of nested objects

Null Handling

JSON null values are handled gracefully - the field is simply not marked as present in the meta struct:

// JSON: {"name": "Alice", "age": null}
def handle(User u, UserMeta meta) : void {
    meta.has_name();  // true
    meta.has_age();   // false (was null)
}

WebSocket

Real-time bidirectional communication with WebSocket servers. The handle is automatically invalidated when the connection closes or errors.

Methods

Method	Description
`WebSocket.connect(url, &onMessage=..., &onOpen=..., &onClose=..., &onError=...)`	Create connection with callback handlers
`send(string msg)`	Send message (only when connected)
`close()`	Close connection
`isConnected()`	Check if WebSocket is connected (handle is valid)

Callback Signatures

Callback	Signature	Description
`onMessage`	`def handler(string msg) : void`	Called when message received
`onOpen`	`def handler : void`	Called when connection opens
`onClose`	`def handler : void`	Called when connection closes
`onError`	`def handler : void`	Called on connection error

Example

component Chat {
    mut WebSocket ws;
    mut string[] messages;
    mut bool connected = false;

    def handleMessage(string msg) : void {
        messages.push(msg);
    }

    def handleOpen() : void {
        connected = true;
        System.log("Connected!");
        ws.send("Hello from Coi!");
    }

    def handleClose() : void {
        connected = false;
        System.log("Disconnected");
    }

    mount {
        ws = WebSocket.connect(
            "wss://chat.example.com",
            &onMessage = handleMessage,
            &onOpen = handleOpen,
            &onClose = handleClose
        );
    }

    def sendMessage(string text) : void {
        if (connected) {
            ws.send(text);
        }
    }

    view {
        <div>
            <p>{connected ? "🟢 Connected" : "🔴 Disconnected"}</p>
            <for msg in messages key={msg}>
                <p>{msg}</p>
            </for>
        </div>
    }
}

Available APIs

Module	Description
`Canvas`	2D drawing, paths, text, images, transformations
`Image`	Image loading for canvas rendering
`Audio`	Audio playback, volume, looping, playback position
`Storage`	Local storage (setItem, removeItem, clear)
`System`	Logging, page title, time, random, URL navigation
`Input`	Keyboard input, pointer lock
`DOMElement`	Direct DOM manipulation
`WebGL`	WebGL context and rendering
`WGPU`	WebGPU support
`FetchRequest`	HTTP GET/POST requests
`WebSocket`	WebSocket connections
`Json`	Type-safe JSON parsing and serialization

Next Steps

Getting Started — Setup and first project
Language Guide — Types, control flow, operators
Components — Component lifecycle, state management

Coi : WASM made easy

artydev — Wed, 21 Jan 2026 12:27:09 +0000

Look at this simple page integrating a Counter demo and its associated code, could it be simpler for a code destinated to be compiled to wasm ?

Bouncing DOM Elements at Warp Speed with Coi to WASM

artydev — Fri, 16 Jan 2026 22:17:11 +0000

This is a balls collisions demo of 100 DOM elements in WASM :

WASMDomCollision

here is the code (Coi language)

component DomBouncer {
    // --- Parameters ---
    int ballCount = 100;
    float width = 800.0;
    float height = 500.0;
    float diameter = 30.0;

    // --- State: Parallel Arrays ---
    mut float[] px = [];
    mut float[] py = [];
    mut float[] vx = [];
    mut float[] vy = [];
    mut string[] ballColors = [];

    // --- State: DOM Handles ---
    mut DOMElement[] ballHandles = [];
    mut DOMElement container;

    init {
        string[] palette = ["#ff4757", "#2ed573", "#1e90ff", "#ffa502", "#a29bfe"];

        for i in 0:100 {
            px.push(100.0 + (System.random() * 600.0));
            py.push(100.0 + (System.random() * 300.0));
            vx.push((System.random() * 400.0) - 200.0);
            vy.push((System.random() * 400.0) - 200.0);
            ballColors.push(palette[i % 5]);
        }
    }

    mount {
        container = Dom.getElementById("ball-container");

        for i in 0:100 {
            DOMElement el = Dom.createElement("div");

            // FIX: Initialize the string in ONE line so it doesn't need reassignment
            string ballCss = "position:absolute;width:30px;height:30px;border-radius:50%;top:0;left:0;background:" + ballColors[i];

            Dom.setAttribute(el, "style", ballCss);
            Dom.appendChild(container, el);

            ballHandles.push(el);
        }
    }

    tick(float dt) {
        float subDt = dt / 2.0;

        for s in 0:2 {
            for i in 0:100 {
                px[i] = px[i] + (vx[i] * subDt);
                py[i] = py[i] + (vy[i] * subDt);

                if (px[i] < 0.0) { px[i] = 0.0; vx[i] = vx[i] * -1.0; }
                if (px[i] > (width - 30.0)) { px[i] = width - 30.0; vx[i] = vx[i] * -1.0; }
                if (py[i] < 0.0) { py[i] = 0.0; vy[i] = vy[i] * -1.0; }
                if (py[i] > (height - 30.0)) { py[i] = height - 30.0; vy[i] = vy[i] * -1.0; }
            }

            for i in 0:100 {
                for j in 0:100 {
                    if (j > i) {
                        float dx = px[j] - px[i];
                        float dy = py[j] - py[i];
                        float d2 = (dx * dx) + (dy * dy);
                        if (d2 < 900.0) {
                            float tx = vx[i]; float ty = vy[i];
                            vx[i] = vx[j]; vy[i] = vy[j];
                            vx[j] = tx; vy[j] = ty;
                            px[i] = px[i] - (dx * 0.1);
                            py[i] = py[i] - (dy * 0.1);
                        }
                    }
                }
            }
        }

        // Render Step
        for i in 0:100 {
            DOMElement h = ballHandles[i];

            // FIX: Single-line assignments for strings
            string transformStr = "translate3d(" + px[i] + "px," + py[i] + "px,0)";
            string finalStyle = "position:absolute;width:30px;height:30px;border-radius:50%;background:" + ballColors[i] + ";transform:" + transformStr;

            Dom.setAttribute(h, "style", finalStyle);
        }
    }

    style {
        #ball-container {
            position: relative;
            width: 800px;
            height: 500px;
            background: #050505;
            overflow: hidden;
            border: 2px solid #333;
            border-radius: 12px;
            margin: 20px auto;
        }
    }

    view {
        <div id="ball-container">
        </div>
    }
}

app { root = DomBouncer; }

From C++ to WASM via WebCC/Coi

artydev — Sun, 11 Jan 2026 13:07:22 +0000

If, like me, you are intrigued by WASM and you don't how to step in, then give an eye to Coi

Coil let's you code you web app in a declarative way like React and compile it through C++ to WASM with the help of WebCC

I have installed the toolchain in WSL and the compilation is very fast.

There is also a VSCode extention :

import "../components/Button.coi";

component AudioPlayer {
  mut Audio audio;
  mut bool playing = false;
  mut float currentTime = 0;
  mut float duration = 0;
  mut float progress = 0;
  mut int volume = 80;

  mount {
    // Replace with your own audio file URL
    audio = Audio.createAudio(
      "https://cdn.pixabay.com/audio/2025/06/23/audio_e6a00ad257.mp3"
    );
    audio.setVolume(0.8);
    System.log("test" + duration);
  }

  tick(float dt) {
    if (playing) {
      currentTime = audio.getCurrentTime();
      duration = audio.getDuration();

      if (duration > 0) {
        progress = (currentTime / duration) * 100;
      }
    }
  }

  def togglePlay(): void {
    if (playing) {
      audio.pause();
      playing = false;
    } else {
      audio.play();
      playing = true;
      duration = audio.getDuration();
    }
  }

  def volumeUp(): void {
    if (volume < 100) {
      volume = volume + 10;

      if (volume > 100) {
        volume = 100;
      }

      float vol = volume / 100.0;
      audio.setVolume(vol);
    }
  }

  def volumeDown(): void {
    if (volume > 0) {
      volume = volume - 10;

      if (volume < 0) {
        volume = 0;
      }

      float vol = volume / 100.0;
      audio.setVolume(vol);
    }
  }

  style {
    .audio-player {
      display: flex;
      flex-direction: column;
      gap: 20px;
      padding: 40px;
      background: #fff;
      border: 1px solid #eee;
      border-radius: 12px;
      width: 280px;
    }

    .label {
      font-size: 12px;
      text-transform: uppercase;
      letter-spacing: 1px;
      color: #999;
      text-align: center;
    }

    .track-info {
      text-align: center;
    }

    .track-title {
      font-size: 18px;
      font-weight: 600;
      color: #1a1a1a;
      margin-bottom: 4px;
    }

    .track-artist {
      font-size: 13px;
      color: #666;
    }

    .album-art {
      width: 160px;
      height: 160px;
      background: linear-gradient(135deg, #9477ff 0%, #6b5ce7 100%);
      border-radius: 12px;
      margin: 0 auto;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 60px;
      box-shadow: 0 4px 15px rgba(148, 119, 255, 0.3);
    }

    .progress-container {
      display: flex;
      flex-direction: column;
      gap: 8px;
    }

    .progress-bar {
      width: 100%;
      height: 6px;
      background: #eee;
      border-radius: 3px;
      overflow: hidden;
    }

    .progress-fill {
      height: 100%;
      background: linear-gradient(90deg, #9477ff, #b19fff);
      border-radius: 3px;
      transition: width 0.1s linear;
    }

    .time-info {
      display: flex;
      justify-content: space-between;
      font-size: 12px;
      color: #666;
    }

    .controls {
      display: flex;
      justify-content: center;
      align-items: center;
      gap: 20px;
    }

    .play-btn {
      width: 56px;
      height: 56px;
      border-radius: 50%;
      background: #9477ff;
      border: none;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 20px;
      color: #fff;
      transition: all 0.2s ease;
      box-shadow: 0 4px 15px rgba(148, 119, 255, 0.4);
    }

    .play-btn:hover {
      transform: scale(1.05);
      background: #a388ff;
    }

    .volume-container {
      display: flex;
      align-items: center;
      gap: 8px;
    }

    .volume-icon {
      font-size: 16px;
      color: #666;
    }

    .volume-bar {
      flex: 1;
      height: 6px;
      background: #eee;
      border-radius: 3px;
      overflow: hidden;
    }

    .volume-fill {
      height: 100%;
      background: #9477ff;
      border-radius: 3px;
      transition: width 0.1s ease;
    }

    .volume-btn {
      width: 28px;
      height: 28px;
      border-radius: 50%;
      background: #f5f5f5;
      border: 1px solid #eee;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 14px;
      color: #666;
      transition: all 0.2s ease;
    }

    .volume-btn:hover {
      background: #9477ff;
      color: #fff;
      border-color: #9477ff;
    }

    .volume-text {
      font-size: 12px;
      color: #666;
      width: 35px;
      text-align: right;
    }
  }

  view {
    <div class="audio-player">
      <div class="label">Audio Player</div>

      <div class="album-art">🎵</div>

      <div class="track-info">
        <div class="track-title">Coify</div>
        <div class="track-artist">Demo Track</div>
      </div>

      <div class="progress-container">
        <div class="progress-bar">
          <div
            class="progress-fill"
            style="width: {progress}%;"
          ></div>
        </div>

        <div class="time-info">
          <span>{currentTime}s</span>
          <span>{duration}s</span>
        </div>
      </div>

      <div class="controls">
        <button class="play-btn" onclick={togglePlay}>
          <if playing>
            <span>⏸</span>
          <else>
            <span>▶</span>
          </else>
          </if>
        </button>
      </div>

      <div class="volume-container">
        <span class="volume-icon">🔊</span>

        <button class="volume-btn" onclick={volumeDown}>−</button>

        <div class="volume-bar">
          <div
            class="volume-fill"
            style="width: {volume}%;"
          ></div>
        </div>

        <button class="volume-btn" onclick={volumeUp}>+</button>

        <span class="volume-text">{volume}%</span>
      </div>
    </div>
  }
}


app { root = AudioPlayer; }

Then compile the code (very fast:

python:~/coi/example/src/demos$ coi AudioPlayer.coi  --out ./dist
Processing /home/python/coi/example/src/demos/AudioPlayer.coi...
Processing /home/python/coi/example/src/components/Button.coi...
All files processed. Total components: 2
Generated ./dist/app.css
Running: webcc /tmp/coi_build/app.cc --out /home/python/coi/example/src/demos/./dist --cache-dir /tmp/coi_build/webcc_cache --template /tmp/coi_build/index.template.html
[WebCC] Loading definitions from compiled-in schema...
[WebCC] Loaded 130 commands and 17 events.
[WebCC] Scanning source files for features...
  -> Found get_body (dom), embedding JS support.
  -> Found create_element (dom), embedding JS support.
  -> Found set_attribute (dom), embedding JS support.
  -> Found append_child (dom), embedding JS support.
  -> Found remove_element (dom), embedding JS support.
  -> Found set_inner_text (dom), embedding JS support.
  -> Found add_click_listener (dom), embedding JS support.
  -> Found log (system), embedding JS support.
  -> Found set_main_loop (system), embedding JS support.
  -> Found open_url (system), embedding JS support.
  -> Found create_audio (audio), embedding JS support.
  -> Found play (audio), embedding JS support.
  -> Found pause (audio), embedding JS support.
  -> Found set_volume (audio), embedding JS support.
  -> Found get_current_time (audio), embedding JS support.
  -> Found get_duration (audio), embedding JS support.
[WebCC] Generated /home/python/coi/example/src/demos/./dist/app.js
[WebCC] Using template: /tmp/coi_build/index.template.html
[WebCC] Generated /home/python/coi/example/src/demos/./dist/index.html
[WebCC] Compiling...
  [CC] /tmp/coi_build/app.cc
  [CC] /home/python/webcc/src/core/command_buffer.cc
  [CC] /home/python/webcc/src/core/event_buffer.cc
  [CC] /home/python/webcc/src/core/scratch_buffer.cc
  [CC] /home/python/webcc/src/core/libc.cc
[WebCC] Linking...
[WebCC] Success! Run 'python3 -m http.server' in /home/python/coi/example/src/demos/./dist to view.

Here is the output, magic!!! :

python@:~/coi/example/src/demos/dist$ ls -rtl
total 64
-rw-r--r-- 1 python python  4460 Jan 11 14:05 app.css
-rw-r--r-- 1 python python   298 Jan 11 14:05 index.html
-rw-r--r-- 1 python python 13789 Jan 11 14:05 app.js
-rwxr-xr-x 1 python python 34063 Jan 11 14:05 app.wasm

Note the size of the wasm file.

Click below to experiment the demo:

Fetching a large JSON, streaming it to a worker for filtering, and rendering chunks incrementally.

artydev — Thu, 08 Jan 2026 13:23:46 +0000

I am inauguring a new serie called "DevGuides" with the help of AI

Link to chat : Streaming-Workers

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Streaming API Workflow Demo with Progress</title>
  <style>
    body { font-family: sans-serif; padding: 20px; max-width: 900px; margin: auto; }
    h1 { color: #333; }
    h2 { color: #4CAF50; margin-top: 30px; }
    .step { margin: 20px 0; padding: 15px; border-left: 4px solid #4CAF50; background: #f9f9f9; }
    .diagram { font-family: monospace; white-space: pre; background: #eee; padding: 10px; margin-top: 10px; }
    #progress-container { width: 100%; background: #eee; border: 1px solid #ccc; border-radius: 5px; height: 20px; margin: 10px 0; }
    #download-progress, #filter-progress { width: 0%; height: 100%; border-radius: 5px; transition: width 0.2s; }
    #download-progress { background: #2196F3; }
    #filter-progress { background: #4CAF50; margin-top: 5px; }
    #product-list { max-height: 400px; overflow-y: auto; border: 1px solid #ccc; padding: 10px; background: #fafafa; }
    .product { margin: 2px 0; }
  </style>
</head>
<body>
  <h1>Streaming API Workflow Demo with Progress</h1>

  <div class="step">
    <h2>Step 1: Fetch Large JSON Data</h2>
    <p>The main thread fetches JSON from a public API as a stream, updating the download progress as chunks arrive.</p>
  </div>

  <div class="step">
    <h2>Step 2: Send Data to Worker</h2>
    <p>Once chunks are received, they are combined into an array and sent to a Web Worker for filtering to avoid blocking the UI.</p>
  </div>

  <div class="step">
    <h2>Step 3: Worker Filters Data</h2>
    <p>The worker filters items according to criteria and sends filtered chunks back to the main thread.</p>
  </div>

  <div class="step">
    <h2>Step 4: Incremental Rendering</h2>
    <p>The main thread renders filtered chunks immediately while updating the filter progress bar.</p>
  </div>

  <div class="step">
    <h2>Workflow Diagram</h2>
    <div class="diagram">
Main Thread                 Worker
------------                ------------
1. fetch()  --------------&gt;
                              2. receive products array
                              3. filter in chunks
                              4. postMessage(filtered chunk)
5. receive filtered chunk &lt;-------------
6. render chunk in UI
(repeat for each chunk)
    </div>
  </div>

  <h2>Live Demo</h2>
  <p>Blue bar: download progress | Green bar: filtering progress</p>
  <div id="progress-container">
    <div id="download-progress"></div>
  </div>
  <div id="progress-container">
    <div id="filter-progress"></div>
  </div>
  <div id="product-list"></div>

  <script>
    // --- Worker code ---
    const workerBlob = new Blob([`
      self.onmessage = function(e) {
        const { type, products, minPrice, minRating, chunkSize } = e.data;
        if (type === 'PROCESS_PRODUCTS') {
          try {
            let filteredChunk = [];
            for (let i = 0; i < products.length; i++) {
              const p = products[i];
              if (p.price > minPrice && p.rating > minRating) {
                filteredChunk.push(p);
              }
              if (filteredChunk.length === chunkSize) {
                self.postMessage({ type: 'CHUNK', data: filteredChunk, progress: i + 1, total: products.length });
                filteredChunk = [];
              }
            }
            if (filteredChunk.length) {
              self.postMessage({ type: 'CHUNK', data: filteredChunk, progress: products.length, total: products.length });
            }
          } catch (err) {
            self.postMessage({ type: 'ERROR', message: err.message });
          }
        }
      };
    `], { type: 'application/javascript' });

    const worker = new Worker(URL.createObjectURL(workerBlob));

    const container = document.getElementById('product-list');
    const downloadBar = document.getElementById('download-progress');
    const filterBar = document.getElementById('filter-progress');

    worker.onmessage = e => {
      const msg = e.data;
      if (msg.type === 'CHUNK') {
        appendToUI(msg.data);
        const percent = Math.round((msg.progress / msg.total) * 100);
        filterBar.style.width = percent + '%';
      }
      if (msg.type === 'ERROR') console.error('Worker error:', msg.message);
    };

    function appendToUI(products) {
      for (const p of products) {
        const div = document.createElement('div');
        div.className = 'product';
        div.textContent = p.title + ' - $' + p.price + ' - rating ' + p.rating;
        container.appendChild(div);
      }
    }

    async function fetchAndProcess(url, minPrice = 500, minRating = 4.5, chunkSize = 20) {
      const res = await fetch(url);
      const reader = res.body.getReader();
      const decoder = new TextDecoder();
      let buffer = '';
      let totalBytes = res.headers.get('Content-Length') ? parseInt(res.headers.get('Content-Length')) : 0;
      let loadedBytes = 0;
      let products = [];

      // Read stream incrementally
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;

        loadedBytes += value.length;
        downloadBar.style.width = totalBytes ? Math.round((loadedBytes / totalBytes) * 100) + '%' : '50%';

        buffer += decoder.decode(value, { stream: true });
      }

      // Parse JSON once fully loaded
      try {
        const data = JSON.parse(buffer);
        products = data.products || [];
      } catch (err) {
        console.error('JSON parse error:', err);
        return;
      }

      downloadBar.style.width = '100%';

      // Send to worker for filtering
      worker.postMessage({ type: 'PROCESS_PRODUCTS', products, minPrice, minRating, chunkSize }); 
    }

    // --- Start demo ---
    fetchAndProcess('https://dummyjson.com/products?limit=1000');   
  </script>
</body>
</html>

Demo

DEV Community: artydev

Sovereign Dev Agent — .NET 10 single-file port (Native AOT compatible)

Native AOT-Compatible C# Local AI Agent with Ollama Tool Calling

Multi-Session AI Multiplexer That Runs Entirely in Your Browser

A very basis chat app with Ollama

Csharp

Great tips Thank you

I Built a Lightweight Rule Engine for JS, C#, and Dart — Here's How It Works

Berat ARPA ・ Feb 21

COI Components

Components

Basic Structure

State & Mutability

Mutability (mut) and Visibility (pub)

Component Parameters

Parameter Passing Modes

Reference Parameters (&)

Move Semantics (:)

Function Parameters (def)

Component Lifecycle

init {} — Pre-render Setup

mount {} — Post-render Initialization

tick(float dt) {} — Animation Loop

Lifecycle Summary

Logic-Only Components

Persisting Component State

Client-Side Routing

Basic Routing

Passing Props to Routes

Programmatic Navigation

How It Works

Route Summary

Platform APIs

Platform APIs

Type System

No-Copy Types

Canvas

Canvas Methods

CanvasContext2D Methods

Shapes

Paths

Styles

Text

Images

Transforms

Setup Example

Example: Bouncing Ball

Image

Methods

Example

Storage

Methods

Example

Audio

Methods

Example

System

Methods

Example

Input

Methods

Common Key Codes

Example

DOMElement

Methods

Example

Fetch

Methods

Callback Signatures

Example

POST Example

JSON

Methods

Defining Data Types

Callback Signatures

Meta Structs (Presence Checking)

Example: Fetch + Parse

Supported Types

Null Handling

WebSocket

Mutability (`mut`) and Visibility (`pub`)

Reference Parameters (`&`)

Move Semantics (`:`)

Function Parameters (`def`)

`init {}` — Pre-render Setup

`mount {}` — Post-render Initialization

`tick(float dt) {}` — Animation Loop