├── src
    ├── ArtificialApi
    │   ├── appsettings.Development.json
    │   ├── appsettings.json
    │   ├── ArtificialApi.http
    │   ├── Properties
    │   │   └── launchSettings.json
    │   ├── ArtificialApi.csproj
    │   └── Program.cs
    ├── ArtificialCast
    │   ├── ArtificialCast.csproj
    │   └── ArtificialCast.cs
    ├── ArtificialCast.Tests
    │   ├── ArtificialCast.Tests.csproj
    │   └── UnitTest1.cs
    └── ArtificialCast.sln
├── .gitignore
├── API.md
├── LICENSE
└── README.md


/src/ArtificialApi/appsettings.Development.json:
--------------------------------------------------------------------------------
1 | {
2 |   "Logging": {
3 |     "LogLevel": {
4 |       "Default": "Information",
5 |       "Microsoft.AspNetCore": "Warning"
6 |     }
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/ArtificialApi/appsettings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "Logging": {
 3 |     "LogLevel": {
 4 |       "Default": "Information",
 5 |       "Microsoft.AspNetCore": "Warning"
 6 |     }
 7 |   },
 8 |   "AllowedHosts": "*"
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/ArtificialApi/ArtificialApi.http:
--------------------------------------------------------------------------------
 1 | @ArtificialApi_HostAddress = http://localhost:5026
 2 | 
 3 | GET {{ArtificialApi_HostAddress}}/todos/
 4 | Accept: application/json
 5 | 
 6 | ###
 7 | 
 8 | GET {{ArtificialApi_HostAddress}}/todos/1
 9 | Accept: application/json
10 | 
11 | ###
12 | 


--------------------------------------------------------------------------------
/src/ArtificialCast/ArtificialCast.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net9.0</TargetFramework>
 5 |     <ImplicitUsings>enable</ImplicitUsings>
 6 |     <Nullable>enable</Nullable>
 7 |   </PropertyGroup>
 8 | 
 9 |   <ItemGroup>
10 |     <PackageReference Include="NJsonSchema" Version="11.3.2" />
11 |   </ItemGroup>
12 | 
13 | </Project>
14 | 


--------------------------------------------------------------------------------
/src/ArtificialApi/Properties/launchSettings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "$schema": "https://json.schemastore.org/launchsettings.json",
 3 |   "profiles": {
 4 |     "http": {
 5 |       "commandName": "Project",
 6 |       "dotnetRunMessages": true,
 7 |       "launchBrowser": true,
 8 |       "launchUrl": "todos",
 9 |       "applicationUrl": "http://localhost:5026",
10 |       "environmentVariables": {
11 |         "ASPNETCORE_ENVIRONMENT": "Development"
12 |       }
13 |     }
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/ArtificialApi/ArtificialApi.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.Web">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net9.0</TargetFramework>
 5 |     <Nullable>enable</Nullable>
 6 |     <ImplicitUsings>enable</ImplicitUsings>
 7 |     <InvariantGlobalization>true</InvariantGlobalization>
 8 |     <PublishAot>false</PublishAot>
 9 |   </PropertyGroup>
10 | 
11 |   <ItemGroup>
12 |     <ProjectReference Include="../ArtificialCast/ArtificialCast.csproj" />
13 |   </ItemGroup>
14 | 
15 | </Project>
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Build Folders (you can edit these to match your project structure)
 2 | bin/
 3 | obj/
 4 | 
 5 | # User-specific files
 6 | *.user
 7 | *.suo
 8 | *.userosscache
 9 | *.sln.docstates
10 | 
11 | # Logs
12 | *.log
13 | 
14 | # Visual Studio Code
15 | .vscode/
16 | *.code-workspace
17 | 
18 | # Rider
19 | .idea/
20 | *.sln.iml
21 | 
22 | # Dotnet specific
23 | project.lock.json
24 | project.fragment.lock.json
25 | artifacts/
26 | 
27 | # NuGet
28 | *.nupkg
29 | *.snupkg
30 | .nuget/
31 | packages/
32 | 
33 | # Entity Framework
34 | *.efmigration
35 | 
36 | # ASP.NET Scaffolding
37 | ScaffoldingReadMe.txt
38 | 
39 | # Others
40 | *.DS_Store
41 | Thumbs.db


--------------------------------------------------------------------------------
/src/ArtificialCast.Tests/ArtificialCast.Tests.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net9.0</TargetFramework>
 5 |     <ImplicitUsings>enable</ImplicitUsings>
 6 |     <Nullable>enable</Nullable>
 7 |     <IsPackable>false</IsPackable>
 8 |   </PropertyGroup>
 9 | 
10 |   <ItemGroup>
11 |     <PackageReference Include="coverlet.collector" Version="6.0.2" />
12 |     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
13 |     <PackageReference Include="xunit" Version="2.9.2" />
14 |     <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
15 |   </ItemGroup>
16 | 
17 |   <ItemGroup>
18 |     <ProjectReference Include="../ArtificialCast/ArtificialCast.csproj" />
19 |   </ItemGroup>
20 | 
21 |   <ItemGroup>
22 |     <Using Include="Xunit" />
23 |   </ItemGroup>
24 | 
25 | </Project>
26 | 


--------------------------------------------------------------------------------
/API.md:
--------------------------------------------------------------------------------
 1 | # API
 2 | 
 3 | ## ArtificialCast AC
 4 | 
 5 | Transforms any object into another type using structured inference and LLMs.
 6 | 
 7 | ```csharp
 8 | public static Task<TOut> AC<TIn, TOut>(TIn input);
 9 | ```
10 | 
11 | ## ArtificialFactory AF
12 | Generates an object of the specified type using type metadata.
13 | 
14 | ```csharp
15 | public static Task<T> AF<T>();
16 | ```
17 | 
18 | ## ArtificialMerge AM
19 | Merges two unrelated objects into a new type using structured inference.
20 | 
21 | ```csharp
22 | public static Task<TOut> AM<T1, T2, TOut>(T1 input1, T2 input2);
23 | ```
24 | 
25 | ### ArtificialSplit AS
26 | Splits a single object into two separate types using structured inference.
27 | 
28 | ```csharp
29 | public static Task<(Tuple<TOut1, TOut2>)> AS<TIn, TOut1, TOut2>(TIn input);
30 | ```
31 | 
32 | ## ArtificialQuery AQ
33 | Performs a natural language query on an object or array, returning a plausible result.
34 | 
35 | ```csharp
36 | public static Task<TOut> AQ<TIn, TOut>(TIn input, string query);
37 | ```
38 | 
39 | ## ArtificialCast Configuration
40 | ```csharp
41 | // This is required to be set to a model (like gemma3:4b)
42 | public static string Model { get; set; } = "";
43 | 
44 | // These are optional
45 | public static string Host { get; set; } = "http://localhost:11434";
46 | public static string SystemPrompt { get; set; } = "...";
47 | ```


--------------------------------------------------------------------------------
/src/ArtificialCast.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.0.31903.59
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ArtificialCast", "ArtificialCast\ArtificialCast.csproj", "{D2484EDC-E207-4A1E-91FB-1ADE4BC9000F}"
 7 | EndProject
 8 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ArtificialCast.Tests", "ArtificialCast.Tests\ArtificialCast.Tests.csproj", "{42833AF1-742B-4BAC-8A78-B7F23EE835A9}"
 9 | EndProject
10 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ArtificialApi", "ArtificialApi\ArtificialApi.csproj", "{400208BB-42AD-4B43-98B8-694B02CC257D}"
11 | EndProject
12 | Global
13 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
14 | 		Debug|Any CPU = Debug|Any CPU
15 | 		Release|Any CPU = Release|Any CPU
16 | 	EndGlobalSection
17 | 	GlobalSection(SolutionProperties) = preSolution
18 | 		HideSolutionNode = FALSE
19 | 	EndGlobalSection
20 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
21 | 		{D2484EDC-E207-4A1E-91FB-1ADE4BC9000F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
22 | 		{D2484EDC-E207-4A1E-91FB-1ADE4BC9000F}.Debug|Any CPU.Build.0 = Debug|Any CPU
23 | 		{D2484EDC-E207-4A1E-91FB-1ADE4BC9000F}.Release|Any CPU.ActiveCfg = Release|Any CPU
24 | 		{D2484EDC-E207-4A1E-91FB-1ADE4BC9000F}.Release|Any CPU.Build.0 = Release|Any CPU
25 | 		{42833AF1-742B-4BAC-8A78-B7F23EE835A9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
26 | 		{42833AF1-742B-4BAC-8A78-B7F23EE835A9}.Debug|Any CPU.Build.0 = Debug|Any CPU
27 | 		{42833AF1-742B-4BAC-8A78-B7F23EE835A9}.Release|Any CPU.ActiveCfg = Release|Any CPU
28 | 		{42833AF1-742B-4BAC-8A78-B7F23EE835A9}.Release|Any CPU.Build.0 = Release|Any CPU
29 | 		{400208BB-42AD-4B43-98B8-694B02CC257D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
30 | 		{400208BB-42AD-4B43-98B8-694B02CC257D}.Debug|Any CPU.Build.0 = Debug|Any CPU
31 | 		{400208BB-42AD-4B43-98B8-694B02CC257D}.Release|Any CPU.ActiveCfg = Release|Any CPU
32 | 		{400208BB-42AD-4B43-98B8-694B02CC257D}.Release|Any CPU.Build.0 = Release|Any CPU
33 | 	EndGlobalSection
34 | EndGlobal
35 | 


--------------------------------------------------------------------------------
/src/ArtificialApi/Program.cs:
--------------------------------------------------------------------------------
 1 | global using static ArtificialCast.ArtificialCast;
 2 | 
 3 | using System.Text;
 4 | using System.Text.Json;
 5 | using System.Text.Json.Serialization;
 6 | 
 7 | var builder = WebApplication.CreateBuilder(args);
 8 | 
 9 | builder.Services.ConfigureHttpJsonOptions(options =>
10 | {
11 |     options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default);
12 | });
13 | 
14 | var app = builder.Build();
15 | 
16 | app.Map("{**catchall}", async (HttpContext context) =>
17 | {
18 |     try
19 |     {
20 |         var apiRequest = new WebRequest
21 |         {
22 |             Method = context.Request.Method,
23 |             Path = context.Request.Path + context.Request.QueryString,
24 |             Headers = context.Request.Headers.ToDictionary(h => h.Key, h => h.Value.ToString()),
25 |             Body = await new StreamReader(context.Request.Body).ReadToEndAsync()
26 |         };
27 | 
28 |         Console.WriteLine($"Request: {apiRequest.Method} {apiRequest.Path}");
29 |         try
30 |         {
31 |             var apiResponse = await AC<WebRequest, FilledWebResponse>(apiRequest);
32 | 
33 |             context.Response.StatusCode = apiResponse.StatusCode;
34 | 
35 |             if (apiResponse.Headers != null)
36 |             {
37 |                 foreach (var kvp in apiResponse.Headers)
38 |                     context.Response.Headers[kvp.Key] = kvp.Value;
39 |             }
40 | 
41 |             if (!string.IsNullOrWhiteSpace(apiResponse.GeneratedBody))
42 |             {
43 |                 context.Response.Headers.Remove("Content-Length");
44 |                 await context.Response.WriteAsync(apiResponse.GeneratedBody);
45 |             }
46 |         }
47 |         catch (Exception acEx)
48 |         {
49 |             Console.Error.WriteLine($"Error in AC function: {acEx.Message}");
50 |             context.Response.StatusCode = StatusCodes.Status500InternalServerError;
51 |             await context.Response.WriteAsync("An error occurred while processing the request.");
52 |         }
53 |     }
54 |     catch (Exception ex)
55 |     {
56 |         Console.Error.WriteLine($"Error: {ex.Message}");
57 |         context.Response.StatusCode = StatusCodes.Status500InternalServerError;
58 |         await context.Response.WriteAsync("An internal server error occurred.");
59 |     }
60 | });
61 | 
62 | app.Run();
63 | 
64 | public class WebRequest
65 | {
66 |     public string AdditionalModelInstructions = "In case css is used, it must be inline or appended as a <style> tag after the body. Output json when it makes sense. Ouput html where it makes sense. Ouput long html pages if not api. CSS must be fancy and modern with complex layouts. YOU MUST RESPECT CSSTHEME PARAMETERS. Ouput the full response always. Do not truncate.";
67 |     public string Seed = Guid.NewGuid().ToString();
68 |     public string Method { get; set; }
69 |     public string Path { get; set; }
70 |     public Dictionary<string, string> Headers { get; set; }
71 |     public string? Body { get; set; }
72 | }
73 | 
74 | public class FilledWebResponse
75 | {
76 |     public int StatusCode { get; set; }
77 |     public Dictionary<string, string>? Headers { get; set; }
78 |     public string GeneratedBody { get; set; }
79 | }
80 | 
81 | [JsonSerializable(typeof(WebRequest))]
82 | [JsonSerializable(typeof(FilledWebResponse))]
83 | internal partial class AppJsonSerializerContext : JsonSerializerContext { }
84 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | NOT FOR USE LICENSE
 2 | 
 3 | This software (the “Software”) is provided solely for demonstrative purposes to illustrate intentionally unsafe, ill-advised, or architecturally unsound software design patterns. It is made available as source code for academic and cautionary examination only.
 4 | 
 5 | It is explicitly NOT open-source software. This license does NOT grant any rights to use, copy, modify, distribute, or deploy the Software in any capacity beyond private review for educational or academic purposes.
 6 | 
 7 | You (the “User”) are expressly prohibited from:
 8 | 
 9 | 1. Using the Software in any production, testing, staging, integration, development, demo, or internal tooling environment.
10 | 2. Incorporating the Software, in whole or in part, into any software intended for use by any third party, customer, company, or system, regardless of purpose.
11 | 3. Distributing the Software, modified or unmodified, in Binary, Source, Floppy Disk, or otherwise, except as permitted below.
12 | 4. Presenting the Software as an example of recommended practice, best practice, or viable architecture.
13 | 
14 | Permitted Academic Use:
15 | 
16 | You may, without prior permission:
17 | 
18 | - Study and execute the Software in private for educational or academic purposes.
19 | - Reference, quote, or excerpt portions of the Software in scientific or technical publications, provided appropriate attribution is given.
20 | - Include small, attributed snippets of the Software in instructional or scholarly materials for teaching, documentation, or commentary.
21 | 
22 | These exceptions are granted only for non-commercial, non-deployed, and scholarly contexts.
23 | 
24 | Note on GitHub Terms of Service:
25 | By making this repository public, GitHub's Terms Of Service (https://docs.github.com/en/site-policy/github-terms/github-terms-of-service#5-license-grant-to-other-users) allow others to view and fork the repository. This does not override or nullify the terms of this license. Forking for review is permitted; usage in any form beyond what is outlined above remains strictly prohibited.
26 | 
27 | The Software is provided “AS IS”, without warranty of any kind, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, non-infringement, non-malware behavior, correctness, reliability, or moral defensibility.
28 | 
29 | By accessing, viewing, or retaining a copy of the Software, you agree to the following:
30 | 
31 | - You understand this Software is not safe for use.
32 | - You accept all risk and liability resulting from exposure to the Software.
33 | - You will not run the Software in any live, distributed, or production context.
34 | - You will not seek support, maintenance, or sympathy from the authors or maintainers.
35 | - You acknowledge that deploying this Software constitutes a willful act of technical malpractice.
36 | 
37 | In no event shall the authors, contributors, or distributors be held liable for any damage, loss, cost, liability, claim, or regret arising out of or in connection with the Software or its use in violation of this license.
38 | 
39 | This is not a joke. Do not use this. You’ve been warned.
40 | 
41 | 
42 | 
43 | License Text Reuse:
44 | 
45 | The text of this license is dedicated to the public domain under the Creative Commons Zero (CC0) license. You may copy, modify, repurpose, or redistribute this license text for any purpose, without attribution or restriction. This does not apply to the Software itself, which remains under the terms of this license.
46 | 


--------------------------------------------------------------------------------
/src/ArtificialCast.Tests/UnitTest1.cs:
--------------------------------------------------------------------------------
 1 | global using static ArtificialCast.ArtificialCast;
 2 | 
 3 | using System;
 4 | using System.Collections.Generic;
 5 | using System.Text.Json;
 6 | using System.Text.Json.Serialization;
 7 | using System.Threading.Tasks;
 8 | using ArtificialCast;
 9 | using Xunit;
10 | 
11 | namespace ArtificialCast.Tests
12 | {
13 |     public class Spaceship
14 |     {
15 |         public string Model { get; set; }
16 |         public int Health { get; set; }
17 |         public int Speed { get; set; }
18 |         public List<string> Weapons { get; set; }
19 |     }
20 | 
21 |     public class Song
22 |     {
23 |         public string Title { get; set; }
24 |         public string Artist { get; set; }
25 |         public int DurationInSeconds { get; set; }
26 |     }
27 | 
28 |     public class Playlist
29 |     {
30 |         public string Name { get; set; }
31 |         public List<Song> Songs { get; set; } = new();
32 |     }
33 | 
34 |     public class OldBloatedUser
35 |     {
36 |         public string Name { get; set; }
37 |         public int Age { get; set; }
38 |         public string Email { get; set; }
39 |         public string Address { get; set; }
40 |         public string PhoneNumber { get; set; }
41 |         public string[] Interests { get; set; }
42 |     }
43 |     public class UserContent
44 |     {
45 |         public string Bio { get; set; }
46 |         public string ProfilePictureUrl { get; set; }
47 |         public List<string> Posts { get; set; } = new();
48 |     }
49 |     public class UserCredentials
50 |     {
51 |         public string Username { get; set; }
52 |         public string Password { get; set; }
53 |         public string Email { get; set; }
54 |     }
55 |     public class UserPreferences
56 |     {
57 |         public string Theme { get; set; }
58 |         public bool NotificationsEnabled { get; set; }
59 |         public string Language { get; set; }
60 |     }
61 |     public class NewUser
62 |     {
63 |         public string Name { get; set; }
64 |         public int Age { get; set; }
65 |         public UserPreferences Preferences { get; set; }
66 |         public UserCredentials Credentials { get; set; }
67 |         public UserContent Content { get; set; }
68 |     }
69 | 
70 |     public class UnitTest1
71 |     {
72 |         JsonSerializerOptions WriteIntendedJson = new JsonSerializerOptions { WriteIndented = true };
73 | 
74 |         [Fact]
75 |         public async Task Test1()
76 |         {
77 |             var oldUser = await AF<OldBloatedUser>();
78 |             var oldUserPrefs = await AF<UserPreferences>();
79 |             var newUser = await AC<OldBloatedUser, NewUser>(oldUser);
80 |             newUser = await AM<NewUser, UserPreferences, NewUser>(newUser, oldUserPrefs);
81 |             var AFUser = await AF<NewUser>();
82 |             var playlist = await AM<NewUser, NewUser, Playlist>(newUser, AFUser);
83 |             var song = await AQ<Song[], Song>([..playlist.Songs], "Find the single longest song, please. No array.");
84 | 
85 |             Console.WriteLine($"Old User: {JsonSerializer.Serialize(oldUser, WriteIntendedJson)}");
86 |             Console.WriteLine($"Old User Prefs: {JsonSerializer.Serialize(oldUserPrefs, WriteIntendedJson)}");
87 |             Console.WriteLine($"New User: {JsonSerializer.Serialize(newUser, WriteIntendedJson)}");
88 |             Console.WriteLine($"AF User: {JsonSerializer.Serialize(AFUser, WriteIntendedJson)}");
89 |             Console.WriteLine($"Playlist: {JsonSerializer.Serialize(playlist, WriteIntendedJson)}");
90 |             Console.WriteLine($"Song: {JsonSerializer.Serialize(song, WriteIntendedJson)}");
91 |         }
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/src/ArtificialCast/ArtificialCast.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Text;
  3 | using System.Text.Json;
  4 | using System.Text.Json.Serialization;
  5 | using NJsonSchema;
  6 | 
  7 | namespace ArtificialCast;
  8 | 
  9 | public static class ArtificialCast
 10 | {
 11 |     #region Configuration
 12 |     public static string Host = "http://localhost:11434";
 13 |     public static string Model = "";
 14 |     public static string SystemPrompt = """ 
 15 |     You are a conversion assistant. Given two class definitions and input data, your job is to generate plausible output data in the target format
 16 |     You always return valid JSON matching the target structure, even if you have to invent or infer values. Do not output anything but JSON.
 17 |     Do not output markdown. Do not wrap the output in an object like {{ 'result': [...] }}. Only output the array directly if an array is requested.
 18 |     You must not state that you are an AI model.
 19 |     You must pretend data to be real and plausible.
 20 |     You must infer and invent data to make it plausible.
 21 |     Content must always fill the request with proper sounding data.
 22 |     Do not generate things like 'this is an example' or 'this provides information about the topic' placeholders.
 23 |     You must not output null values on non-nullable properties.
 24 |     You must fill requested values with plausible data.
 25 |     When asked to merge objects, merge what you can, fill the rest and only ever output the requested type.
 26 |     Do not generate an array, unless specified by the schema.
 27 |     If asked to query something, return the requested value only. Do not generate an array if not specified.
 28 |     If asked to query something, respect the query EXACTLY. Do not add anything else.
 29 |     Seriously, don't generate an array unless explicitly asked for it. Please.
 30 |     Make sure to respect the output types defined in the schema.
 31 |     """;
 32 |     #endregion
 33 |     #region Utility
 34 |     static string ExtractJsonResponse(string response)
 35 |     {
 36 |         var jsonStart = response.IndexOf('{');
 37 |         var jsonEnd = response.LastIndexOf('}');
 38 |         if (jsonStart == -1 || jsonEnd == -1 || jsonEnd < jsonStart)
 39 |             throw new Exception("Invalid JSON response");
 40 | 
 41 |         return response.Substring(jsonStart, jsonEnd - jsonStart + 1);
 42 |     }
 43 | 
 44 |     static async Task<string> RequestFromOllama(string prompt){
 45 |         var request = new
 46 |         {
 47 |             model = Model,
 48 |             prompt = prompt,
 49 |             stream = false,
 50 |             system = SystemPrompt,
 51 |             options = new
 52 |             {
 53 |                 temperature = 1,
 54 |             },
 55 |         };
 56 | 
 57 |         var jsonRequest = JsonSerializer.Serialize(request);
 58 |         var httpClient = new HttpClient();
 59 |         var response = await httpClient.PostAsync($"{Host}/api/generate", new StringContent(jsonRequest, Encoding.UTF8, "application/json"));
 60 |         var result = await response.Content.ReadAsStringAsync();
 61 |         return result;
 62 |     }
 63 |     #endregion
 64 |     #region AC
 65 |     public static async Task<TOutput> AC<TInput, TOutput>(TInput input)
 66 |     {
 67 |         var json = JsonSerializer.Serialize(input, new JsonSerializerOptions
 68 |         {
 69 |             WriteIndented = true,
 70 |             PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
 71 |             Converters = { new JsonStringEnumConverter() }
 72 |         });
 73 | 
 74 |         var outputTypeJson = JsonSchema.FromType<TOutput>().ToJson();
 75 | 
 76 |         var prompt = $"""
 77 |             Convert the following object of type {typeof(TInput)} to an object of type {typeof(TOutput)}.
 78 | 
 79 |             Input object: {json}
 80 | 
 81 |             Output type definition: {outputTypeJson}
 82 |             """;
 83 | 
 84 |         var response = await RequestFromOllama(prompt);
 85 |         // The response is json containing a "result" field. We want that field.
 86 |         var modelResponse = JsonDocument.Parse(response).RootElement;
 87 |     
 88 |         var jsonResponse = modelResponse.GetProperty("response").GetString();
 89 |         if (string.IsNullOrWhiteSpace(jsonResponse))
 90 |             throw new InvalidOperationException("LLM returned null or empty response.");
 91 |         Console.WriteLine($"LLM response: {jsonResponse}");
 92 |         jsonResponse = ExtractJsonResponse(jsonResponse);
 93 | 
 94 |         TOutput? output;
 95 |         
 96 |         try{
 97 |             output = JsonSerializer.Deserialize<TOutput>(jsonResponse);
 98 |         }
 99 |         catch (JsonException ex)
100 |         {
101 |             throw new InvalidOperationException("Failed to deserialize LLM response.", ex);
102 |         }
103 |         
104 |         if (output == null)
105 |             throw new InvalidOperationException("Deserialization resulted in a null value.");
106 |         
107 |         return output;
108 |     }
109 |     #endregion
110 |     #region AF
111 |     class ObjectCreationRequest
112 |     {
113 |         public string Prompt { get; set; }
114 |     }
115 |     class ObjectCreationResponse<T>
116 |     {
117 |         public T Instance { get; set; }
118 |     }
119 |     public static async Task<TOutput> AF<TOutput>(string prompt = "Randomly filled object")
120 |     {
121 |         var request = new ObjectCreationRequest
122 |         {
123 |             Prompt = prompt
124 |         };
125 | 
126 |         ObjectCreationResponse<TOutput> response = await AC<ObjectCreationRequest, ObjectCreationResponse<TOutput>>(request);
127 | 
128 |         return response.Instance;
129 |     }
130 |     #endregion
131 |     #region AM
132 |     class ObjectMergeRequest<TInput, TInput2>
133 |     {
134 |         public TInput Input { get; set; }
135 |         public TInput2 Input2 { get; set; }
136 |     }
137 |     class ObjectMergeResponse<TOutput>
138 |     {
139 |         public TOutput MergedInstance { get; set; }
140 |     }
141 |     public static async Task<TOutput> AM<TInput, TInput2, TOutput>(TInput input, TInput2 input2)
142 |     {
143 |         var request = new ObjectMergeRequest<TInput, TInput2>
144 |         {
145 |             Input = input,
146 |             Input2 = input2
147 |         };
148 | 
149 |         ObjectMergeResponse<TOutput> response = await AC<ObjectMergeRequest<TInput, TInput2>, ObjectMergeResponse<TOutput>>(request);
150 | 
151 |         return response.MergedInstance;
152 |     }
153 |     #endregion
154 |     #region AS
155 |     class ObjectSplitRequest<TInput>
156 |     {
157 |         public TInput Input { get; set; }
158 |     }
159 |     class ObjectSplitResponse<TOutput, TOutput2>
160 |     {
161 |         public TOutput Instance { get; set; }
162 |         public TOutput2 Instance2 { get; set; }
163 |     }
164 |     public static async Task<Tuple<TOutput, TOutput2>> AS<TInput, TOutput, TOutput2>(TInput input)
165 |     {
166 |         var request = new ObjectSplitRequest<TInput>
167 |         {
168 |             Input = input
169 |         };
170 | 
171 |         ObjectSplitResponse<TOutput, TOutput2> response = await AC<ObjectSplitRequest<TInput>, ObjectSplitResponse<TOutput, TOutput2>>(request);
172 | 
173 |         return new Tuple<TOutput, TOutput2>(response.Instance, response.Instance2);
174 |     }
175 |     #endregion
176 |     #region AQ
177 |     class ObjectQueryRequest<TInput>
178 |     {
179 |         public TInput Input { get; set; }
180 |         public string Query { get; set; }
181 |     }
182 |     class ObjectQueryResponse<TOutput>
183 |     {
184 |         public TOutput Instance { get; set; }
185 |     }
186 |     public static async Task<TOutput> AQ<TInput, TOutput>(TInput input, string query)
187 |     {
188 |         var request = new ObjectQueryRequest<TInput>
189 |         {
190 |             Input = input,
191 |             Query = query
192 |         };
193 | 
194 |         ObjectQueryResponse<TOutput> response = await AC<ObjectQueryRequest<TInput>, ObjectQueryResponse<TOutput>>(request);
195 | 
196 |         return response.Instance;
197 |     }
198 |     #endregion
199 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # ArtificialCast
  2 | 
  3 | [![Read the README](https://img.shields.io/badge/Read%20the%20Full%20README-blue?style=for-the-badge&color=blue)](./README.md)  
  4 | [![Do Not Use](https://img.shields.io/badge/Do%20Not%20Use-critical?style=for-the-badge&color=red)](#not-for-use-license)
  5 | 
  6 | *Type-safe transformation powered by inference.*
  7 | 
  8 | ArtificialCast is a lightweight, type-safe casting and transformation utility powered by large language models. It allows seamless conversion between strongly typed objects using only type metadata, JSON schema inference, and prompt-driven reasoning.
  9 | 
 10 | > Imagine a world where `Convert.ChangeType()` could transform entire object graphs, infer missing values, and adapt between unrelated types - without manual mapping or boilerplate.
 11 | 
 12 | ArtificialCast makes that possible.
 13 | 
 14 | ## Features
 15 | 
 16 | * **Zero config** - Just define your types.
 17 | * **Bidirectional casting** - Cast any type to any other.
 18 | * **Schema-aware inference** - Auto-generates JSON Schema for the target type.
 19 | * **LLM-powered transformation** - Uses AI to "fill in the blanks" between input and output.
 20 | * **Testable & deterministic-ish** - Works beautifully until it doesn't.
 21 | 
 22 | ## Quick Start
 23 | 
 24 | ArtificialCast provides a suite of transformation utilities under the `ArtificialCast.*` namespace. These methods allow you to:
 25 | 
 26 | * Generate objects from type definitions
 27 | * Transform between different models
 28 | * Merge and split structured data
 29 | * Perform natural language-powered queries over in-memory datasets
 30 | 
 31 | Each method is fully typed, testable, and powered by structured inference.
 32 | 
 33 | ```csharp
 34 | global using static ArtificialCast.ArtificialCast; // Optional but makes it easier to call the methods
 35 | using ArtificialCast; // Alternative
 36 | ```
 37 | 
 38 | ```csharp
 39 | // Not optional due to LLM licenses. Set to a model of your choice (tested locally with gemma3:4b)
 40 | ArtificialCast.Model = "your-model-of-choice"; 
 41 | 
 42 | var result = await AC<Apple, Fruit>(apple);
 43 | ```
 44 | 
 45 | ## Example: Object Migration
 46 | 
 47 | ```csharp
 48 | var result = await AC<LegacyUserDTO, NewUserModel>(legacyUser);
 49 | ```
 50 | 
 51 | ArtificialCast will:
 52 | 
 53 | * Serialize the `legacyUser`
 54 | * Generate a JSON schema from `NewUserModel`
 55 | * Prompt a local LLM (like `gemma3:4b`) to "convert" the object
 56 | * Return a deserialized instance of `NewUserModel`
 57 | 
 58 | That's it. No mapping code. No rules. Just structure and vibes.
 59 | 
 60 | ## Example: Request → Response
 61 | 
 62 | ```csharp
 63 | public class MathRequest
 64 | {
 65 |     public List<string> Tokens { get; set; }
 66 | }
 67 | 
 68 | public class MathResponse
 69 | {
 70 |     public List<string> Steps { get; set; }
 71 |     public double Result { get; set; }
 72 | }
 73 | ```
 74 | 
 75 | ```csharp
 76 | var request = new MathRequest
 77 | {
 78 |     Tokens = new() { "(", "2", "+", "3", ")", "*", "4", "-", "6", "/", "3" }
 79 | };
 80 | 
 81 | var response = await AC<MathRequest, MathResponse>(request);
 82 | ```
 83 | 
 84 | **Output:**
 85 | 
 86 | ```json
 87 | {
 88 |   "steps": [
 89 |     "2 + 3",
 90 |     "(2 + 3) * 4",
 91 |     "(2 + 3) * 4 - 6 / 3"
 92 |   ],
 93 |   "result": 14
 94 | }
 95 | ```
 96 | 
 97 | Looks good, right?
 98 | 
 99 | You'd think that's correct.
100 | It's not. The actual answer is 18.
101 | But the output **looks** correct, and the structure matches.
102 | 
103 | > This is the **failure mode of success**.
104 | 
105 | ## The BIGPISS Stack
106 | 
107 | **Behavior-Inferred Generation: Prompt-Oriented Infrastructure for Simulated Software**
108 | 
109 | All BIGPISS functions are implemented in the `ArtificialCast.*` namespace and are fully functional.
110 | Each operation internally uses `AC<TIn, TOut>` under the hood, but provides a tailored interface for clarity, ergonomics, and demonstration purposes.
111 | 
112 | ArtificialCast is part of the **BIGPISS** stack - a set of tools that replaces conventional logic with inference, structure, and prompt design.
113 | **Behavior-Inferred Generation: Prompt-Oriented Infrastructure for Simulated Software**
114 | 
115 | | Function                                | Signature          | Description                                                                                                      |
116 | | --------------------------------------- | ------------------ | ---------------------------------------------------------------------------------------------------------------- |
117 | | `AC<TIn, TOut>`                         | Artificial Cast    | Transform anything into anything. No mapping logic. Just types and vibes.                                        |
118 | | `AF<T>`                                 | Artificial Factory | Generate an object from nothing but a type definition.                                                           |
119 | | `AM<T1, T2, TOut>`                      | Artificial Merge   | Combine unrelated inputs into a coherent (enough) output.                                                        |
120 | | `AS<TIn, TOut1, TOut2>`                 | Artificial Split   | Split a single input into two outputs. How? Ask the void.                                                        |
121 | | `AQ<TOut>(IEnumerable<object>, string)` | Artificial Query   | Perform fake queries on real arrays using natural language. Returns plausible lies.                              |
122 | | `BIGPISS`                               | The whole thing    | The architectural umbrella for inference-driven, hallucination-backed, type-safe simulations of actual software. |
123 | 
124 | ## Example: Full flexibility
125 | 
126 | ```csharp
127 | var oldUser = await AF<OldBloatedUser>(); // create a new OldBloatedUser out of nothing
128 | var oldUserPrefs = await AF<UserPreferences>(); // create a new UserPreferences
129 | var newUser = await AC<OldBloatedUser, NewUser>(oldUser); // migrate the old user to a new user
130 | newUser = await AM<NewUser, UserPreferences, NewUser>(newUser, oldUserPrefs); // merge the new user with the old user preferences
131 | var AFUser = await AF<NewUser>(); // create a new user out of nothing
132 | var playlist = await AM<NewUser, NewUser, Playlist>(newUser, AFUser); // turn two users into a playlist?
133 | var song = await AQ<Song[], Song>([..playlist.Songs], "Find the single longest song, please. No array."); // Just no.
134 | 
135 | Console.WriteLine($"Old User: {JsonSerializer.Serialize(oldUser, WriteIntendedJson)}");
136 | Console.WriteLine($"Old User Prefs: {JsonSerializer.Serialize(oldUserPrefs, WriteIntendedJson)}");
137 | Console.WriteLine($"New User: {JsonSerializer.Serialize(newUser, WriteIntendedJson)}");
138 | Console.WriteLine($"AF User: {JsonSerializer.Serialize(AFUser, WriteIntendedJson)}");
139 | Console.WriteLine($"Playlist: {JsonSerializer.Serialize(playlist, WriteIntendedJson)}");
140 | Console.WriteLine($"Song: {JsonSerializer.Serialize(song, WriteIntendedJson)}");
141 | ```
142 | 
143 | This **works and outputs very different results** on every run. The full test is in [`UnitTest1.cs`](./src/ArtificialCast.Tests/UnitTest1.cs).
144 | 
145 | ## What Is Virtual Software?
146 | 
147 | **Virtual Software** is software that was never written - only described.
148 | 
149 | Instead of implementing logic, developers define input and output types, and let language models fill in the gaps. The result is simulated behavior generated at runtime based entirely on structure, schema, and high-level intent.
150 | 
151 | ### Characteristics:
152 | 
153 | * **No source of truth**: Only types and prompts define behavior.
154 | * **Ephemeral execution**: Each run is a new hallucination.
155 | * **Failure is indistinguishable from success**: Outputs are correct in form, not in meaning.
156 | 
157 | Virtual Software blurs the line between logic and suggestion. It appears functional, passes tests, and integrates cleanly. But beneath the surface, it has no actual reasoning - just inference.
158 | 
159 | This is the domain where **ArtificialCast** thrives.
160 | 
161 | ## Why This Exists
162 | 
163 | ArtificialCast is a demonstration of what happens when overhyped AI ideas are implemented *exactly as proposed* - with no shortcuts, no mocking, and no jokes.
164 | 
165 | It is fully functional. It passes tests. It integrates into modern .NET workflows.
166 | **And it is fundamentally unsafe.**
167 | 
168 | This project exists because:
169 | 
170 | * AI-generated "logic" is rapidly being treated as production-ready.
171 | * Investors are funding AI frameworks that operate entirely on structure and prompts.
172 | * Developers deserve to see what happens when you follow that philosophy *to its logical conclusion*.
173 | 
174 | ArtificialCast is the result.
175 | 
176 | It works. Until it doesn't. And when it doesn't, it fails in ways that *look* like success. That's the danger.
177 | 
178 | ## Getting Started Locally
179 | 
180 | ### Requirements
181 | 
182 | * .NET 9 SDK or later
183 | * [Ollama](https://ollama.com/) installed and running locally
184 | * A local model: e.g. `gemma3:4b` or equivalent
185 | 
186 | ### Setup
187 | 
188 | ```bash
189 | 
190 | # Clone the repository into your solution
191 | git clone
192 | 
193 | # Add project reference to your solution and restore dependencies
194 | dotnet sln add ./ArtificialCast/src/ArtificialCast/ArtificialCast.csproj
195 | dotnet restore
196 | 
197 | # Add reference to your project
198 | cd YourProject
199 | dotnet add reference ../ArtificialCast/src/ArtificialCast/ArtificialCast.csproj
200 | 
201 | # Install Ollama if not already installed
202 | brew install ollama   # macOS
203 | # or
204 | choco install ollama  # Windows
205 | # or
206 | yay -S ollama  # Arch Linux (btw)
207 | # or see https://ollama.com/download for other platforms
208 | 
209 | # Pull the model used by ArtificialCast
210 | # Others may work, but this is the default
211 | # Behavior may differ between models
212 | ollama pull *model*
213 | 
214 | # Start the Ollama server (usually automatic)
215 | ollama serve
216 | ```
217 | 
218 | ArtificialCast will default to sending requests to:
219 | 
220 | ```
221 | http://127.0.0.1:11434/api/generate
222 | ```
223 | 
224 | No keys, no cloud, no nonsense.
225 | 
226 | ## NOT FOR USE LICENSE
227 | 
228 | Note: While this license restricts use and redistribution, GitHub's Terms of Service permit public repositories to be forked and viewed. Forking does not imply permission to use the software beyond the limitations set in this license. Any such use remains strictly prohibited.
229 | 
230 | This software is provided solely for **demonstrative**, **educational**, and **academic** purposes.
231 | It may be referenced in technical papers, articles, or presentations - but it is **not to be used in any deployed system** under any circumstance.
232 | 
233 | ### You May:
234 | 
235 | * Study and execute the software in private for educational purposes.
236 | * Reference the software in scientific or technical publications with proper credit.
237 | * Use small, attributed excerpts in academic or instructional material.
238 | 
239 | ### You May Not:
240 | 
241 | * Use the software in production, testing, demo, or internal tooling environments.
242 | * Embed or incorporate it into any system intended for human or machine use.
243 | * Redistribute it, in part or whole, outside the context of scholarly work.
244 | 
245 | This project is a **functioning satire** of emerging AI engineering trends.
246 | 
247 | > It is not a joke. It just isn't funny.
248 | 
249 | [LICENSE](./LICENSE) is a more formal version of this license.
250 | 
251 | ## Conclusion
252 | 
253 | ArtificialCast is the worst idea executed exceptionally well. It serves as a mirror to modern AI-infused dev practices, highlighting what happens when we **trade correctness for convenience and call it innovation**.
254 | 
255 | **Don't use it. Study it. Cite it. Fear it.**
256 | 
257 | ## Documentation License
258 | 
259 | The contents of this `README.md` (and any related documentation) are licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).
260 | 
261 | > You are free to share and adapt the text for academic, educational, and referential use - as long as proper attribution is given.
262 | 
263 | This applies **only** to documentation. The source code remains under the [NOT FOR USE LICENSE](./LICENSE).
264 | 
265 | ## Footnote
266 | 
267 | > This readme was partially edited in a conversation that - like all LLM interactions - is itself just a loop of `ChatRequest -> ChatResponse`.
268 | 
269 | ArtificialCast is not a parody of future software.
270 | 
271 | **It is future software.**


--------------------------------------------------------------------------------