Program.cs

using Ideal.Existence;
using System.Text.Json;

namespace Ideal
{
    internal static class Program
    {
        private sealed record Options
        {
            public string ExistenceId { get; init; } = "033";
            public int Cycles { get; init; } = 20;
            public string Format { get; init; } = "text";
            public bool IncludeEngineLogs { get; init; } = false;
            public bool ListInstructionalAssets { get; init; } = false;
            public string ExportInstructionalAssetsDir { get; init; } = string.Empty;
            public bool PrintInstructionalReadme { get; init; } = false;
        }

        private sealed class StepOutput
        {
            public int Step { get; init; }
            public string Mood { get; init; } = string.Empty;
            public string[] EngineLogs { get; init; } = Array.Empty<string>();
        }

        private static int Main(string[] args)
        {
            if (!TryParseArgs(args, out Options options, out string error, out bool showHelp))
            {
                if (!showHelp)
                {
                    Console.Error.WriteLine(error);
                    Console.Error.WriteLine();
                    PrintUsage();
                    return 1;
                }

                PrintUsage();
                return 0;
            }

            IExistence existence = CreateExistence(options);
            string format = options.Format.ToLowerInvariant();

            if (options.ListInstructionalAssets)
            {
                return ListInstructionalAssets();
            }

            if (options.PrintInstructionalReadme)
            {
                return PrintInstructionalReadme();
            }

            if (!string.IsNullOrWhiteSpace(options.ExportInstructionalAssetsDir))
            {
                return ExportInstructionalAssets(options.ExportInstructionalAssetsDir);
            }

            for (int i = 0; i < options.Cycles; i++)
            {
                (string mood, string[] engineLogs) = RunStep(existence);

                if (format == "json")
                {
                    StepOutput output = new StepOutput
                    {
                        Step = i,
                        Mood = mood,
                        EngineLogs = options.IncludeEngineLogs ? engineLogs : Array.Empty<string>()
                    };

                    Console.WriteLine(JsonSerializer.Serialize(output, new JsonSerializerOptions
                    {
                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
                    }));
                    continue;
                }

                foreach (string line in engineLogs)
                    Console.WriteLine(line);

                Console.WriteLine(i + ": " + mood);
            }

            return 0;
        }

        private static (string Mood, string[] EngineLogs) RunStep(IExistence existence)
        {
            using StringWriter capture = new StringWriter();
            TextWriter originalOut = Console.Out;
            Console.SetOut(capture);

            string mood;
            try
            {
                mood = existence.Step();
            }
            finally
            {
                Console.SetOut(originalOut);
            }

            string logs = capture.ToString();
            if (string.IsNullOrWhiteSpace(logs))
                return (mood, Array.Empty<string>());

            string[] lines = logs
                .Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);

            return (mood, lines);
        }

        private static bool TryParseArgs(string[] args, out Options options, out string error, out bool showHelp)
        {
            options = new Options();
            error = string.Empty;
            showHelp = false;

            for (int i = 0; i < args.Length; i++)
            {
                string arg = args[i];
                switch (arg)
                {
                    case "-h":
                    case "--help":
                        showHelp = true;
                        return false;
                    case "-e":
                    case "--existence":
                        if (!TryReadNext(args, ref i, out string existenceId))
                        {
                            error = "Missing value for --existence.";
                            return false;
                        }

                        options = options with { ExistenceId = NormalizeExistence(existenceId) };
                        if (!IsValidExistence(options.ExistenceId))
                        {
                            error = "Invalid --existence value. Use one of: 010, 020, 030, 031, 032, 033, 040.";
                            return false;
                        }
                        break;
                    case "-c":
                    case "--cycles":
                        if (!TryReadNext(args, ref i, out string cyclesRaw))
                        {
                            error = "Missing value for --cycles.";
                            return false;
                        }

                        if (!int.TryParse(cyclesRaw, out int cycles) || cycles < 1)
                        {
                            error = "Invalid --cycles value. It must be an integer >= 1.";
                            return false;
                        }

                        options = options with { Cycles = cycles };
                        break;
                    case "-f":
                    case "--format":
                        if (!TryReadNext(args, ref i, out string formatRaw))
                        {
                            error = "Missing value for --format.";
                            return false;
                        }

                        string normalizedFormat = formatRaw.ToLowerInvariant();
                        if (normalizedFormat != "text" && normalizedFormat != "json")
                        {
                            error = "Invalid --format value. Use: text or json.";
                            return false;
                        }

                        options = options with { Format = normalizedFormat };
                        break;
                    case "--include-engine-logs":
                        options = options with { IncludeEngineLogs = true };
                        break;
                    case "--list-instructional-assets":
                        options = options with { ListInstructionalAssets = true };
                        break;
                    case "--print-instructional-readme":
                        options = options with { PrintInstructionalReadme = true };
                        break;
                    case "--export-instructional-assets":
                        if (!TryReadNext(args, ref i, out string exportDir))
                        {
                            error = "Missing value for --export-instructional-assets.";
                            return false;
                        }

                        options = options with { ExportInstructionalAssetsDir = exportDir };
                        break;
                    default:
                        error = $"Unknown argument: {arg}";
                        return false;
                }
            }

            return true;
        }

        private static bool TryReadNext(string[] args, ref int index, out string value)
        {
            if (index + 1 >= args.Length)
            {
                value = string.Empty;
                return false;
            }

            index++;
            value = args[index];
            return true;
        }

        private static string NormalizeExistence(string value)
        {
            string cleaned = value.Trim();
            if (cleaned.StartsWith("existence", StringComparison.OrdinalIgnoreCase))
                cleaned = cleaned["existence".Length..];

            return cleaned.PadLeft(3, '0');
        }

        private static bool IsValidExistence(string id)
        {
            return id == "010" ||
                   id == "020" ||
                   id == "030" ||
                   id == "031" ||
                   id == "032" ||
                   id == "033" ||
                   id == "040";
        }

        private static IExistence CreateExistence(Options options)
        {
            return options.ExistenceId switch
            {
                "010" => new Existence010(),
                "020" => new Existence020(),
                "030" => new Existence030(),
                "031" => new Existence031(),
                "032" => new Existence032(),
                "033" => new Existence033(),
                _ => new Existence040()
            };
        }

        private static int ListInstructionalAssets()
        {
            if (!TryGetInstructionalAssetFiles(out string[] files, out string error))
            {
                Console.Error.WriteLine(error);
                return 1;
            }

            foreach (string file in files)
                Console.WriteLine(file);

            return 0;
        }

        private static int ExportInstructionalAssets(string outputDir)
        {
            if (!TryGetInstructionalAssetFiles(out string[] files, out string error))
            {
                Console.Error.WriteLine(error);
                return 1;
            }

            Directory.CreateDirectory(outputDir);
            foreach (string sourceFile in files)
            {
                string destinationFile = Path.Combine(outputDir, Path.GetFileName(sourceFile));
                File.Copy(sourceFile, destinationFile, overwrite: true);
                Console.WriteLine(destinationFile);
            }

            return 0;
        }

        private static int PrintInstructionalReadme()
        {
            if (!TryGetInstructionalAssetFiles(out string[] files, out string error))
            {
                Console.Error.WriteLine(error);
                return 1;
            }

            string readmePath = files.FirstOrDefault(path =>
                string.Equals(Path.GetFileName(path), "README-04-self-programming.md", StringComparison.OrdinalIgnoreCase)) ?? string.Empty;

            if (string.IsNullOrWhiteSpace(readmePath))
            {
                Console.Error.WriteLine("Instructional README not found. Expected README-04-self-programming.md.");
                return 1;
            }

            Console.Write(File.ReadAllText(readmePath));
            return 0;
        }

        private static bool TryGetInstructionalAssetFiles(out string[] files, out string error)
        {
            string[] candidates = new[]
            {
                Path.Combine(AppContext.BaseDirectory, "instructions"),
                Path.Combine(Directory.GetCurrentDirectory(), "instructions"),
                Path.Combine(Directory.GetCurrentDirectory(), "images")
            };

            List<string> fileList = new List<string>();
            foreach (string candidate in candidates)
            {
                if (Directory.Exists(candidate))
                {
                    fileList.AddRange(Directory.GetFiles(candidate));
                }
            }

            files = fileList
                .Distinct(StringComparer.Ordinal)
                .OrderBy(path => path, StringComparer.Ordinal)
                .ToArray();

            if (files.Length > 0)
            {
                error = string.Empty;
                return true;
            }

            error = "Instructional assets not found. Expected /app/instructions in the container.";
            return false;
        }

        private static void PrintUsage()
        {
            Console.WriteLine("Usage:");
            Console.WriteLine("  ideal [--existence <id>] [--cycles <n>] [--format <text|json>] [--include-engine-logs]");
            Console.WriteLine("  ideal --list-instructional-assets");
            Console.WriteLine("  ideal --print-instructional-readme");
            Console.WriteLine("  ideal --export-instructional-assets <output-dir>");
            Console.WriteLine();
            Console.WriteLine("Examples:");
            Console.WriteLine("  ideal --existence 033 --cycles 20 --format text");
            Console.WriteLine("  ideal --existence 033 --cycles 30 --format json --include-engine-logs");
            Console.WriteLine("  ideal --print-instructional-readme");
            Console.WriteLine("  ideal --export-instructional-assets /output");
            Console.WriteLine();
            Console.WriteLine("Valid existence IDs: 010, 020, 030, 031, 032, 033, 040");
        }
    }
}