Janady13/AI_Brain / infra/omnicron_iface.cs

Source identity

Field	Recorded value
Source type	GitHub source
Original record	Janady13/AI_Brain / infra/omnicron_iface.cs
Date	Not specified in source
Repository	Janady13/AI_Brain
Revision	6d0767aad08781eb5c4e1eb14a42ec92c437be78
Branch	copilot/convert-python-files-to-csharp
Path or archive member	infra/omnicron_iface.cs
Original SHA-256	2ef4170b6d8ac1ea10ece6859406530cfdc7b5177fdd0546a4f6fcf223fd75f1
Git blob SHA	2be2de01a9afc9cfe18b29e5d23a1eeefcc25263
Reading-copy SHA-256	2ef4170b6d8ac1ea10ece6859406530cfdc7b5177fdd0546a4f6fcf223fd75f1

Original source ↗

Recovered source transcript

Download complete source text ↓186 lines · 5.6 KB

// Omnicron interface for structured logging and task tracking

using System;
using System.Collections.Generic;
using System.Text.Json;

namespace AIBrain.Infra
{
    public class OmnicronIface
    {
        private static readonly string[] REDACTIONS = new[] { "OMNICRON_TOKEN" };

        private static Dictionary<string, object> RedactEnv(Dictionary<string, object> data)
        {
            var output = new Dictionary<string, object>(data);
            var token = Environment.GetEnvironmentVariable("OMNICRON_TOKEN");
            
            if (!string.IsNullOrEmpty(token))
            {
                foreach (var key in new List<string>(output.Keys))
                {
                    if (output[key] is string strValue && strValue.Contains(token))
                    {
                        output[key] = strValue.Replace(token, "***REDACTED***");
                    }
                }
            }

            return output;
        }

        private static void Emit(Dictionary<string, object> payload)
        {
            payload = RedactEnv(payload);
            try
            {
                var json = JsonSerializer.Serialize(payload);
                Console.WriteLine(json);
                Console.Out.Flush();
            }
            catch
            {
                // Avoid breaking callers on logging failures
            }
        }

        public class TaskContext : IDisposable
        {
            private readonly string name;
            private readonly string runId;
            private readonly double startTime;
            private readonly Dictionary<string, object> fields;
            private bool disposed = false;
            private Exception exception = null;

            public TaskContext(string name, Dictionary<string, object> fields = null)
            {
                this.name = name;
                this.runId = Guid.NewGuid().ToString();
                this.startTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 1000.0;
                this.fields = fields ?? new Dictionary<string, object>();

                var payload = new Dictionary<string, object>
                {
                    ["ts"] = startTime,
                    ["type"] = "task_start",
                    ["task"] = name,
                    ["run_id"] = runId
                };

                foreach (var kvp in this.fields)
                    payload[kvp.Key] = kvp.Value;

                Emit(payload);
            }

            public void SetException(Exception ex)
            {
                exception = ex;
            }

            public void Dispose()
            {
                if (disposed)
                    return;

                disposed = true;

                var endTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 1000.0;
                var elapsed = endTime - startTime;

                var payload = new Dictionary<string, object>
                {
                    ["ts"] = endTime,
                    ["type"] = "task_end",
                    ["task"] = name,
                    ["run_id"] = runId,
                    ["status"] = exception == null ? "ok" : "error",
                    ["elapsed_s"] = Math.Round(elapsed, 6)
                };

                if (exception != null)
                {
                    payload["err"] = new Dictionary<string, object>
                    {
                        ["type"] = exception.GetType().Name,
                        ["msg"] = exception.Message
                    };
                }

                foreach (var kvp in fields)
                    payload[kvp.Key] = kvp.Value;

                Emit(payload);
            }
        }

        public static TaskContext Task(string name, Dictionary<string, object> fields = null)
        {
            return new TaskContext(name, fields);
        }

        public static void Log(string eventName, Dictionary<string, object> fields = null)
        {
            var payload = new Dictionary<string, object>
            {
                ["ts"] = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 1000.0,
                ["type"] = "event",
                ["event"] = eventName
            };

            if (fields != null)
            {
                foreach (var kvp in fields)
                    payload[kvp.Key] = kvp.Value;
            }

            Emit(payload);
        }

        public static void Notify(string level, string message, Dictionary<string, object> ctx = null)
        {
            var payload = new Dictionary<string, object>
            {
                ["ts"] = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 1000.0,
                ["type"] = "notify",
                ["level"] = level,
                ["message"] = message
            };

            if (ctx != null)
            {
                foreach (var kvp in ctx)
                    payload[kvp.Key] = kvp.Value;
            }

            Emit(payload);
        }

        public class Artifact
        {
            public void Put(string path, string name)
            {
                Log("artifact_put", new Dictionary<string, object>
                {
                    ["path"] = path,
                    ["name"] = name,
                    ["provider"] = "shim"
                });
            }

            public void Get(string name, string dest)
            {
                Log("artifact_get", new Dictionary<string, object>
                {
                    ["name"] = name,
                    ["dest"] = dest,
                    ["provider"] = "shim"
                });
            }
        }

        public static readonly Artifact artifact = new Artifact();
    }
}