Personal

SkaiiNyght Solutions LLC

A South Dakota company formed March 2026. 6 repositories, one author.

Projects · 6 repositories

skaii-meals

What it is

A meal-planning application. The user says what they are into and what they want to hit, and the system produces a grocery list first and then meals built from that list. Macro tracking is available when wanted and never required to get started.

Two front ends over one backend: a user-facing Blazor WebAssembly PWA, and a Blazor Server admin console that talks to its module directly with no HTTP API in between. AI providers are swapped by configuration behind a single chat-client abstraction.

Goal

The flagship product of SkaiiNyght Solutions LLC. Grocery-list-first, the inverse of recipe-first planners; macro-capable when the user wants it, plain grocery list when they do not. Built as a full rewrite in a fresh repository (2026-03) after the original was rewritten in place until live code could no longer be told from dead code.

Stack

Runtime.NET 10
APIFastEndpoints, FluentValidation, Swagger
DataPostgreSQL, EF Core (Npgsql), DbUp migrations
User UIBlazor WebAssembly (PWA), MudBlazor, Refit, CommunityToolkit.Mvvm
Admin UIBlazor Server, MudBlazor, direct module reference
AuthJWT bearer, OpenID Connect
AIMicrosoft.Extensions.AI `IChatClient` (Claude, Gemini, OpenAI selectable)
Real-time / cacheSignalR with Redis backplane, Redis caching and rate limiting
ResiliencePolly via `Microsoft.Extensions.Http.Polly`
LoggingNLog (database target)
TestsNUnit, NSubstitute, bUnit, Playwright end-to-end
External dataFatSecret (nutrition), Walmart (pricing)

skaii-auth

What it is

A multi-application authentication service and the admin console that manages it. One identity provider serves every Skaii application, with per-application isolation, a two-tier security model (user JWT and service API key), and a cross-device approval flow.

Originally a hand-built identity stack: magic link, cross-device login, OAuth (Google, Facebook, Apple), RSA-SHA256 JWT issuance with key rotation, JWKS/OIDC discovery, refresh-token rotation, token revocation, rate limiting and IP blocking. Identity has since been migrated to self-hosted Zitadel in phases; the custom code that Zitadel replaces is being decommissioned. The admin console (Skaii.ApplicationManager.Web) stays for non-identity concerns: applications, users, roles, subscriptions, blocked IPs, audit history.

Goal

Stop building auth into every product. One service owns sign-in, tokens and application registration; each product integrates through a client library and a callback URL set. The Zitadel migration trades custom identity code for a maintained platform while keeping the multi-application isolation and the cross-device UX that were built first.

Stack

Runtime.NET 10
APIFastEndpoints, FluentValidation
Identity platformZitadel, self-hosted (post-migration)
TokensRSA-SHA256 JWT, JWKS, OIDC discovery, `System.IdentityModel.Tokens.Jwt`
DataPostgreSQL (application and log databases), EF Core (Npgsql), DbUp migrations
Admin UIBlazor Server, MudBlazor, CommunityToolkit.Mvvm
EmailResend
Client`Skaii.Auth.Client` (Refit) consumed by the other Skaii applications
LoggingNLog (database target)
TestsNUnit, xUnit, NSubstitute, FluentAssertions, integration tests via `Mvc.Testing`

skaii-cali

What it is

A mobile-first, offline-first calisthenics training tracker. A monorepo with three deployables: a .NET API, a thin Blazor Server operator app, and an Expo React Native app, plus shared TypeScript packages for domain logic, the generated API client and the sync engine.

The domain math (tempo, distance/duration/pace, volume, personal bests, rest placement) is written twice, once in C# and once in TypeScript, and held identical by shared JSON test vectors.

Goal

Log training on a phone with no signal and never lose a rep. Absent is not zero, left and right sides never merge, qualifying conditions travel with results, and sync conflicts surface to the athlete rather than being resolved silently. Design is spec-driven: roughly 270 functional requirements, a data model with stated modeling principles, and a constitution that forbids marking a task done without the command output that proves it.

Stack

Backend runtime.NET 10
APIFastEndpoints, OpenAPI, Scalar, FluentValidation
DataPostgreSQL, Dapper (Npgsql), DbUp migrations
Operator UIBlazor Server
AuthJWT bearer
LoggingSerilog (console, file, PostgreSQL sinks)
MobileExpo SDK 57, React Native, expo-router, dev-client, EAS build profiles
On-device dataexpo-sqlite, Drizzle ORM
Shared TS packagescore` (domain), `api-client` (generated), `sync-engine
Monorepopnpm workspaces, ESLint
TestsxUnit (.NET), shared JSON vectors across both languages, end-to-end project

skaii-pathfinder

What it is

A Pathfinder 2e repository for one campaign: character builds, rules research and findings, plus a .NET tool (aoncorpus) that stocks and queries a rules corpus taken from a pinned snapshot of the Archives of Nethys. A Claude Code skill, /build-guide, generates a validated build guide against that corpus. Specs 003 and 004 cover a character-sheet PDF and a Foundry VTT export.

Setup is one script. It reads uname first and exits on a kernel it was not written for, then runs the .NET SDK, PostgreSQL 18 and pgvector from pinned container images so nothing is installed on the host. A corpus pull that cannot assert the pinned index id refuses to stock and falls back to the committed snapshot.

Goal

Rules prose that is checked against the rules, not against memory. The corpus is pinned so a generated guide is reproducible, and the setup is portable so the same guide can be regenerated on another machine with nothing but a container runtime.

Stack

Runtime.NET 10
CLISystem.CommandLine
DataPostgreSQL 18, pgvector, Dapper (Npgsql), DbUp migrations
Semantic searchMicrosoft.ML.OnnxRuntime, Microsoft.ML.Tokenizers, Microsoft.Extensions.AI, System.Numerics.Tensors
SetupPOSIX shell, Podman (tested) or Docker (accepted), pinned container images
TestsxUnit v3 — unit, integration, contract and setup suites
Agent surfaceClaude Code skill `/build-guide`

skaii-skills

What it is

The source material for the Claude Code skills used across the other repositories: the briefs that generate a skill, the generations produced, the run logs, the specs, and the incident reports where a skill did the wrong thing. Skills covered: gauntlet (parallel review round with a ledger), forge (build a change in an isolated worktree and review it before it lands), terse-mode, gitlab-mr and gitlab-mr-loop.

Skill material only. The .NET tools those skills call (ledger, forge, gl-mr) are built and recorded in skaii-tools; a feature's record lives with the code it governs.

Goal

Make agent-driven development reviewable. Every skill has a written brief, every generation is kept, and every failure that reached a developer's tree has a dated post-mortem with root cause and the guard that came out of it.

Stack

FormatMarkdown — skill briefs, `SKILL.md` generations, reviewer briefs, spec-kit records
RuntimeClaude Code skills and subagents
Tooling calledledger`, `forge`, `gl-mr` from `skaii-tools
Processspec-kit (`/speckit-*`), `.specify/` constitution

skaii-tools

What it is

Small, single-purpose command-line tools built to be run by an agent. Each reports what it found and under-claims where it cannot tell. No CI pipeline; the tools are run locally by whoever, or whatever, is doing the work.

Tool What it does
falsify Corrupts a subject on purpose, runs the subject's own checks against each corruption, and reports which corruptions the checks failed to notice.
record-guards Checks a spec-governed feature record — spec, plan, decision log, contracts — for the ways those documents quietly stop agreeing with each other and with the code.
forge Carries out a code change in an isolated git worktree, proves it builds there, and hands it to a review round before it reaches the developer's tree. Ported from 1,471 lines of Bash.
ledger The only writer of the gauntlet ledger. Review agents have no write tool; this is how they record anything, and it refuses to write outside the round's directory.
gl-mr Resolves a token, verifies the account, scans for secrets before anything leaves the machine, checks the target branch, and opens the merge request.

Each tool is self-contained: its own src/, tests/, specs/ and prompts/. The Bash-to-.NET ports are held to byte-identical output by a parity corpus and capture manifest.

Goal

Tools that check work rather than produce it, so an agent's claim of success is measured instead of trusted. A test suite that would not notice a bug, a spec that no longer matches the code, a patch applied to the wrong tree — each has a tool whose only job is to say so.

Stack

Runtime.NET 10
Code analysisMicrosoft.CodeAnalysis.CSharp (Roslyn)
Semantic checksMicrosoft.Extensions.AI, Microsoft.ML.OnnxRuntime, Microsoft.ML.Tokenizers, Pgvector
DataPostgreSQL (Npgsql), DbUp migrations
LoggingNLog via `Microsoft.Extensions.Logging`
ValidationFluentValidation
TestsNUnit, xUnit v3, NSubstitute; VSTest and Microsoft.Testing.Platform runners selected per tool by `global.json`
Paritycorpus.tsv` and capture manifest, `tools/parity-capture/capture.sh