Janady13/AI_Brain / daemon/seed_common.cs

Source identity

Field	Recorded value
Source type	GitHub source
Original record	Janady13/AI_Brain / daemon/seed_common.cs
Date	Not specified in source
Repository	Janady13/AI_Brain
Revision	6d0767aad08781eb5c4e1eb14a42ec92c437be78
Branch	copilot/convert-python-files-to-csharp
Path or archive member	daemon/seed_common.cs
Original SHA-256	3be766419a31c7cc8ea0dcc22d209a3809bb9ab12439869557ff74f2c8abd607
Git blob SHA	6fa39cd93250e101d30321922a5738336ba78a79
Reading-copy SHA-256	3be766419a31c7cc8ea0dcc22d209a3809bb9ab12439869557ff74f2c8abd607
Original source ↗
Recovered source transcript

Download complete source text ↓194 lines · 6.5 KB
// Local seeding utilities following 12-factor config

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using Npgsql;

namespace AIBrain.Daemon
{
    public static class SeedCommon
    {
        private static readonly string DEFAULT_DB;
        private static readonly string DEFAULT_USER;
        private static readonly string DEFAULT_HOST;
        private static readonly int DEFAULT_PORT;
        private static readonly bool DRY_RUN;
        private static readonly string SOURCE_TAG;

        static SeedCommon()
        {
            DEFAULT_DB = Environment.GetEnvironmentVariable("PGDATABASE") 
                ?? Environment.GetEnvironmentVariable("DB_NAME") 
                ?? "brain_atomic";
            
            DEFAULT_USER = Environment.GetEnvironmentVariable("PGUSER") 
                ?? Environment.GetEnvironmentVariable("DB_USER") 
                ?? "postgres";

            // Prefer Brain volume sockets if present, then External, then home dir, else localhost
            DEFAULT_HOST = Environment.GetEnvironmentVariable("PGHOST")
                ?? Environment.GetEnvironmentVariable("DB_HOST")
                ?? GetFirstExistingPath(new[]
                {
                    "/Volumes/Brain/AI_Brain/pg",
                    "/Volumes/Brain/HiveExpansion/pg",
                    "/Volumes/External/AI_Brain/pg",
                    Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AI_Brain", "pg")
                })
                ?? "localhost";

            DEFAULT_PORT = int.Parse(
                Environment.GetEnvironmentVariable("PGPORT") 
                ?? Environment.GetEnvironmentVariable("DB_PORT") 
                ?? "5432");

            var dryRunVar = Environment.GetEnvironmentVariable("DRY_RUN") ?? "0";
            DRY_RUN = new[] { "1", "true", "yes", "on" }.Contains(dryRunVar.ToLower());

            SOURCE_TAG = Environment.GetEnvironmentVariable("SEED_SOURCE") ?? "Hive500Expansion";
        }

        private static string GetFirstExistingPath(string[] paths)
        {
            foreach (var path in paths)
            {
                if (Directory.Exists(path))
                    return path;
            }
            return null;
        }

        public static string ComputeHash(string sentence)
        {
            using (var sha256 = SHA256.Create())
            {
                var bytes = Encoding.UTF8.GetBytes(sentence);
                var hashBytes = sha256.ComputeHash(bytes);
                return BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
            }
        }

        public static NpgsqlConnection ConnectDb()
        {
            if (DRY_RUN)
                return null;

            var connectionString = $"Host={DEFAULT_HOST};Port={DEFAULT_PORT};Database={DEFAULT_DB};Username={DEFAULT_USER}";
            return new NpgsqlConnection(connectionString);
        }

        private const string INSERT_SQL = 
            "INSERT INTO atomic_facts (hash, sentence, category, source, created_at) " +
            "VALUES (@hash, @sentence, @category, @source, now()) ON CONFLICT (hash) DO NOTHING;";

        public static (int attempted, int inserted) InsertMany(string category, IEnumerable<string> items)
        {
            int attempted = 0;
            int inserted = 0;
            
            var conn = ConnectDb();
            NpgsqlCommand cmd = null;

            try
            {
                if (conn != null)
                {
                    conn.Open();
                    cmd = conn.CreateCommand();
                    cmd.CommandText = INSERT_SQL;
                }

                foreach (var s in items)
                {
                    var sentence = s.Trim();
                    if (string.IsNullOrEmpty(sentence))
                        continue;

                    if (!sentence.EndsWith("."))
                        sentence = $"{sentence}.";

                    var hash = ComputeHash(sentence);
                    attempted++;

                    if (DRY_RUN)
                    {
                        inserted++;
                        continue;
                    }

                    cmd.Parameters.Clear();
                    cmd.Parameters.AddWithValue("@hash", hash);
                    cmd.Parameters.AddWithValue("@sentence", sentence);
                    cmd.Parameters.AddWithValue("@category", category);
                    cmd.Parameters.AddWithValue("@source", SOURCE_TAG);
                    cmd.ExecuteNonQuery();
                }
            }
            finally
            {
                cmd?.Dispose();
                conn?.Close();
                conn?.Dispose();
            }

            return (attempted, DRY_RUN ? inserted : attempted);
        }

        public static List<string> ReadFileLines(string path, int limit)
        {
            var seen = new HashSet<string>();
            var output = new List<string>();

            foreach (var raw in File.ReadLines(path))
            {
                var line = raw.Trim();
                if (string.IsNullOrEmpty(line))
                    continue;
                if (seen.Contains(line))
                    continue;

                seen.Add(line);
                output.Add(line);

                if (output.Count >= limit)
                    break;
            }

            return output;
        }

        public static void RunSeed(string category, Func<int, IEnumerable<string>> generator, int limit = 500)
        {
            var start = DateTime.Now;
            var catUpper = category.ToUpper();
            var fileOverride = Environment.GetEnvironmentVariable($"SEED_FILE_{catUpper}") 
                ?? Environment.GetEnvironmentVariable("SEED_FILE");

            List<string> items;
            string modeDetail;

            if (!string.IsNullOrEmpty(fileOverride) && File.Exists(fileOverride))
            {
                items = ReadFileLines(fileOverride, limit);
                modeDetail = $"FILE:{fileOverride}";
            }
            else
            {
                items = generator(limit).ToList();
                modeDetail = "GENERATOR";
            }

            var (attempted, inserted) = InsertMany(category, items);
            var duration = (DateTime.Now - start).TotalSeconds;
            var mode = DRY_RUN ? "DRY_RUN" : "LIVE";

            Console.WriteLine(
                $"✅ {mode} seeded category='{category}' source={modeDetail} attempted={attempted} inserted~={inserted} in {duration:F2}s");
        }
    }
}