Personal monorepo for active projects, learning, and archived work.
33 active packages
discord-stream-lifecycle (2026-06-13)
The @shepherdjerred/discord-stream-lifecycle package provides shared XState v5 state machines that manage Discord Go-Live streaming sessions end-to-end. It is implemented in strict TypeScript with Bun-managed tooling (bun.lock), uses XState’s setup API, and relies on Node stream primitives to coordinate encoders and voice targets. A notable architecture detail is the layered setup where createDesiredStreamMachine composes a raw go-live machine actor to reconcile desired intent with actual Discord topology, handling retries and teardown reasons per snapshot.
discord-video-stream (2026-06-07)
@shepherdjerred/discord-video-stream is a monorepo-maintained fork of @dank074/discord-video-stream that gives streambot, discord-plays-pokemon, and discord-plays-mario-kart a unified Go-Live streaming library. The codebase is TypeScript built via Bun (bun run build) and depends on fluent-ffmpeg, discord.js-selfbot-v13, sharp, @lng2004/node-datachannel, and related WebRTC tooling. A notable upgrade is the seekable player in src/media/player.ts that restarts ffmpeg with an -ss offset while preserving the existing Discord Go-Live connection so scrubbing triggers no visible stream interruption.
discord-plays-mario-kart (2026-06-06)
The project runs Mario Kart 64 headlessly as a cooperative Twitch Plays–style experience where up to four Discord users drive karts in real time from a web UI while the race streams into a voice channel. It relies on a Bun-executed WebAssembly build of a patched N64Wasm core, Socket.IO for controller inputs, and ffmpeg with the in-repo @shepherdjerred/discord-video-stream fork to deliver live video. A notable capability is the custom patch series that injects the ROM directly into wasm memory, exposes the angrylion software framebuffer, and replays per-seat inputs each frame so four virtual controllers stay synchronized without a GPU.
streambot (2026-06-06)
Streambot orchestrates Discord video streaming sessions across guilds, letting users queue, play, and manage media via slash commands and status reporting. It runs on Bun with TypeScript, using discord.js alongside discord.js-selfbot-v13, xstate, zod, and prom-client, plus internal @shepherdjerred packages for command handling and streaming helpers. Configuration is validated once at startup through branded Zod schemas that feed a session manager which leases distinct userbot tokens so each account streams only one voice channel concurrently.
stocks-sjer-red (2026-05-24)
stocks-sjer-red is an Astro-based application that tracks a PC component investment portfolio by loading structured JSON data and computing holdings, cost basis, and performance metrics. It is built with Astro, TypeScript, Tailwind CSS, and Zod, leveraging runtime validation before executing pricing and aggregation logic. A notable capability is the strict Zod PortfolioSchema, which guarantees clean component histories so calculations like current totals and percentage changes remain reliable.
llm-observability (2026-05-19)
The @shepherdjerred/llm-observability package captures and traces LLM interactions so downstream systems can inspect chat requests, responses, and token usage across providers. It is built in TypeScript with Bun tooling and relies on OpenTelemetry APIs together with Zod schemas defined in modules like src/config.ts and the provider wrappers in src/*-wrapper.ts. A dedicated archive pipeline combines ArchiveSpanProcessor with the S3 uploadArchive helper to strip large span bodies, gzip them, and store slim references keyed by service, provider, and date so Tempo and S3 remain synchronized.
trmnl-dashboard (2026-05-09)
TRMNL Dashboard is a Bun standard-library HTTP service that exposes liveness, health, home, and homelab JSON endpoints for TRMNL Private Plugins. The codebase uses TypeScript with Bun tooling (bun:test, bun.lock), Zod validation, and the @shepherdjerred/home-assistant package to structure payloads. Its architecture collects status data from Home Assistant, Prometheus, Alertmanager, Bugsink, PagerDuty, and Kubernetes, enforcing access via an x-api-key header to deliver unified diagnostics.
home-assistant (2026-04-20)
This package provides a strongly typed client that lets JavaScript automation connect to the Home Assistant REST and WebSocket APIs for state queries and service calls. The codebase is written in TypeScript, targets both Bun and Node.js runtimes, and relies on Zod to validate responses while exposing CLI tooling in src/codegen/cli.ts and runtime exports in src/index.ts. Its standout capability is the ha-codegen CLI, which introspects a live Home Assistant instance to emit a schema module that enforces compile-time safety for entity IDs, domains, services, and event payloads.
temporal (2026-04-07)
This project runs a Temporal-based automation service that orchestrates AI agent workflows, alert remediation, and GitHub operations for the shepherdjerred monorepo. It is implemented in Bun with TypeScript using Temporal’s SDK, OpenTelemetry instrumentation, Sentry, Zod, Octokit, and Kubernetes client libraries defined in package.json. A notable capability provisions per-task work directories, validates agent outputs against JSON schemas, and launches alert remediation child tasks that can branch fixes into draft PRs.
leetcode (2026-03-27)
This project provides a local LeetCode search engine that ingests the official problem catalog, editorials, and builds an on-disk database for fast querying. It uses Bun scripts with bun:sqlite, a SQLite FTS5 index, and Python dependencies orchestrated through uv alongside MLX-based bge-m3 embedding generation. The search pipeline fuses BM25 keyword hits and 1024-dimension vector similarities via Reciprocal Rank Fusion to deliver hybrid semantic and keyword retrieval from data/leetcode.db.
toolkit (2026-03-26)
@shepherdjerred/tools is a TypeScript CLI that fetches and formats operational data from Bugsink, PagerDuty, and GitHub to streamline incident response workflows. The codebase runs on the Node.js toolchain defined in package.json, compiles TypeScript sources, and brings in the zod validation library. Command modules in src/commands—such as pr/health.ts—share formatter utilities to deliver modular features like PR health checks that bundle merge-conflict detection with CI status aggregation.
cooklang-rich-preview (2026-03-15)
This project delivers the marketing site promoting the Cooklang Rich Preview Obsidian plugin. It is built with Astro, Tailwind CSS, PostCSS, and TypeScript-driven tooling such as astro-icon and @iconify-json/heroicons. The Astro configuration links .astro/types through src/env.d.ts, giving the site strongly typed component and environment support.
cooklang-for-obsidian (2026-03-06)
Cooklang Rich Preview is an Obsidian plugin that renders .cook recipe files with rich previews, ingredient highlighting, timers, and metadata cards inside the vault. The codebase uses TypeScript with the Obsidian plugin API, CodeMirror editor bindings, and a Chevrotain-powered parser compiled via esbuild and Bun scripts. A custom CookView pairs a CodeMirror editor with a live renderer that builds section-aware recipe layouts and metadata cards from the structured parse tree.
terraform-provider-asuswrt (2026-03-01)
This project implements a Terraform/OpenTofu provider that manages Asuswrt-Merlin routers by orchestrating their HTTP-based NVRAM configuration endpoints. It is written in Go 1.25, using HashiCorp’s Terraform Plugin Framework along with tooling wired through GNUmakefile, go.mod, and go.sum. The internal client and provider packages expose resources such as asuswrt_system and asuswrt_dhcp_static_lease, translating Terraform CRUD operations into router API calls.
tasknotes-types (2026-02-28)
tasknotes-types delivers a reusable schema library that enforces strict typing across task management concepts—covering priorities, statuses, reminders, time tracking, pomodoro state, calendar events, and API request/response shapes. It is implemented in TypeScript with Zod validation, linted via eslint.config.ts, and managed through Bun tooling (bun.lock) alongside the root tsconfig.json. The src/index.ts barrel consolidates all schemas so downstream services can import consistent models for tasks, filters, NLP parsing, and health checks from a single entrypoint.
tasknotes-server (2026-02-26)
Tasknotes Server is a Bun-powered backend that turns Markdown frontmatter into typed task records and exposes automation routes for health checks, NLP parsing, calendars, pomodoro timers, and time tracking. It relies on the Hono HTTP framework with Bun-native testing (bun:test), Zod validation, Gray Matter parsing, Prometheus metrics via prom-client, and Sentry integration for runtime telemetry. A natural-language parser maps inputs like “Fix bug !high p:Backend @office” into structured priorities, projects, contexts, and tags before persisting them through the vault-backed TaskStore.
tasks-for-obsidian (2026-02-23)
Tasks-for-obsidian delivers a React Native mobile client for managing synchronized tasks tied to an Obsidian-centered workflow, complete with in-app sync status and offline cues. It relies on a TypeScript-based stack with React Native, React Navigation, react-native-reanimated, Safe Area Context, and Sentry instrumentation plus vector icon and gesture libraries. A notable capability is the animated connection banner and Kanban board architecture that leverages shared Reanimated state, safe-area awareness, and typed domain models to orchestrate task columns while signaling authentication and sync conditions.
docs (2026-02-22)
Monorepo Documentation is an AI-maintained knowledge base that captures architecture, decisions, guides, plans, and logs for the wider monorepo. The collection is organized as Markdown directories like architecture/, patterns/, and guides/, with automation hooks that rely on Bun scripts and Temporal scheduling workflows. A notable capability is the temporal-agent-task annotation system that lets operators trigger follow-up runs through the Temporal agent-task scheduler via bun run scripts/schedule-agent-task.ts.
monarch (2026-02-21)
Monarch is an AI-driven transaction categorizer for Monarch Money that processes bank data, enriches it with Amazon, Venmo, and Bilt sources, and applies Claude-based merchant classifications. It runs on Bun with a TypeScript codebase that pulls in the Anthropic SDK, Playwright scrapers, pdfjs-dist parsing, and Zod validation across scripts like src/index.ts and its supporting libraries. The architecture uses a multi-tier Claude classifier pipeline with a persistent knowledge base that reconciles Amazon orders to transactions and tracks enrichment statistics.
homelab (2026-02-15)
Homelab provisions and manages a Kubernetes-driven personal infrastructure cluster named torvalds, delivering fully automated deployments and backups through ArgoCD orchestration. The repo uses TypeScript with cdk8s built and bundled by Bun, paired with Talos control-plane scripts and generated Helm chart typings under src/cdk8s/generated/helm. It enforces an ArgoCD app-of-apps architecture with dependency pinning and automated updates that keep Docker images, Helm charts, and Bun packages current.
webring (2026-02-15)
Webring aggregates the latest items from user-defined RSS feeds, implemented in TypeScript with dependencies like rss-parser, remeda, sanitize-html, and truncate-html to fetch, transform, and sanitize entries. It supports an optional cached execution path that stores results on disk via zod-validated configuration, enabling per-source preview filters and shuffle controls before returning the final list.
dotfiles (2026-02-15)
This repository is a personal monorepo aggregating active projects, learning experiments, and archived work under a shared workspace README.md:3. It uses a Bun-powered TypeScript setup with declared workspaces, Lefthook git hooks, Dagger tooling, and Tauri API dependencies managed through package.json:1. A notable capability is the Bun automation script scripts/run-package-script.ts:1, which discovers every package under packages/* and executes a requested script across them while honoring skip lists for selective runs.
anki (2026-02-15)
This package automates turning Markdown study notes (book_high_performance_web_applications.md, book_ostep.md, bytes.md, interview.md) into Anki decks by invoking the mdanki CLI to emit .apkg files. The generate.sh workflow relies on Node.js tooling (npx, mdanki, sql.js) plus a shared settings.json template that defines the card HTML and CSS, and it swaps in the sql-memory-growth.js build of sql.js before running the conversions so every deck is generated with the memory-growth WebAssembly runtime.
better-skill-capped (2026-02-15)
Better Skill Capped is a React web app that rebuilds Skill Capped’s catalog into a richer interface driven by the service’s embedded video manifest. It is built with TypeScript, Vite, Bulma styling, Font Awesome icons, Fuse.js search utilities, and Sentry monitoring. The UI persists bookmarks and viewing status through localStorage-backed datastores, giving users personalized tracking alongside the enhanced catalog view.
scout-for-lol (2026-02-15)
Scout for League of Legends is a Discord bot that tracks your friends’ matches and delivers post-game notifications with rich stat reports directly into your server. The codebase uses React, the Tauri app framework, Zod validation, ffmpeg-static, and both OpenAI and Google Generative AI SDKs (package.json). It runs configurable competitions, supports multi-region player tracking, and generates full arena-mode reports for all teams with augment and placement data.
discord-plays-pokemon (2026-02-15)
Discord Plays Pokémon lets a Discord server collectively play Pokémon Emerald by routing chat button commands into a fully headless emulator stream. The repo centers on a Bun runtime driving the vendored pokeemerald-wasm, encodes frames with ffmpeg, and delivers them over the forked @shepherdjerred/discord-video-stream stack into a Discord voice channel. A Temporal-managed workflow periodically refreshes the packages/backend/assets/pokeemerald.wasm blob so deployments through ArgoCD stay current without manual intervention.
astro-opengraph-images (2026-02-15)
This project ships an Astro integration that generates Open Graph images for every page in a static Astro build. It is written in TypeScript and relies on React-based presets powered by Satori and the @resvg/resvg-js renderer. During the astro:build:done hook it sanitizes HTML with jsdom, extracts Open Graph metadata, and renders customizable presets that cover Astro content collections.
sjer.red (2026-02-15)
This repo powers the sjer.red personal site, delivering blog posts, curated bookmarks, and other content through Astro-driven static pages. It runs on Astro with plugins like @astrojs/mdx, @astrojs/rss, Tailwind CSS, and Node-based utilities such as src/bookmarks/bookmarks.ts that use jsdom and Zod to automate bookmark ingestion, giving the site an automated link curation pipeline.
starlight-karma-bot (2026-02-15)
Starlight Karma Bot is a Discord bot that manages karma points, leaderboards, and history commands for servers. It runs on Bun with discord.js v14, TypeORM backed by SQLite, dotenv/env-var configuration helpers, and Sentry instrumentation declared in package.json:1. The data layer uses TypeORM view entities and an auto-migration routine to keep per-guild stats consistent, combining definitions like src/db/karma-counts.ts:1 and the legacy migration in src/db/auto-migrate.ts:1.
fonts (2026-01-31)
Project provides a command-line workflow to patch Berkeley Mono TTF fonts with Nerd Fonts glyphs, rename them, and optionally install or archive the results. It is implemented as a Python 3.10 script that uses fontTools, fontforge, and the Nerd Fonts FontPatcher fetched with curl. The pipeline caches the patcher in ~/.cache/nerd-fonts-patcher, enforces consistent style naming through a filename-to-style map, and supports post-processing steps like zipping and installing fonts.
resume (2026-01-27)
Repository is a Bun-managed monorepo of personal tools and assets, including a LaTeX resume defined in packages/resume/resume.tex and other workspace packages registered in package.json. It uses Bun scripts with TypeScript, Lefthook, Dagger’s TypeScript SDK, and Tauri APIs declared in package.json for automation and desktop integrations. Build automation is centralized through Dagger configuration in dagger.json, enabling the shared scripts to orchestrate tasks across every workspace.
birmel (2025-12-20)
This project implements the Birmel Discord bot that runs on the Bun runtime to automate guild interactions and AI-driven responses. It leverages concrete technologies like discord.js, @ai-sdk/openai, @prisma/client, @opentelemetry/sdk-node, and @sentry/node for messaging, language models, data access, telemetry, and monitoring. A notable architecture detail is the global Prisma client singleton that reuses the database connection across modules to keep the bot responsive.
eslint-config (2025-12-13)
@shepherdjerred/eslint-config provides reusable ESLint flat configurations that enforce accessibility, import discipline, and component best practices across React, React Native, and Astro codebases. The package integrates @eslint/js, typescript-eslint, eslint-plugin-astro, eslint-plugin-react, eslint-plugin-react-native, eslint-plugin-jsx-a11y, eslint-plugin-import, and the Bun-aware TypeScript resolver exposed in src/configs/*.ts. Its modular configs in src/configs/base.ts, src/configs/imports.ts, src/configs/accessibility.ts, src/configs/react.ts, and src/configs/react-native.ts each return TSESLint.FlatConfig.ConfigArray instances so teams can compose rule sets with custom tsconfig roots, project service settings, and Bun-aware import resolution. The reactNativeConfig adds RN plugin rules, RN globals, disables DOM-specific React rules and Bun-specific rules, and allows PascalCase filenames.
| Directory | Description |
|---|---|
| practice/ | Learning projects - books, courses, coding challenges |
| archive/ | Archived projects - completed or superseded |
bun install # Install dependencies
bun run build # Build all packages
bun run test # Test all packages
bun run typecheck # Typecheck all packagesSee CLAUDE.md for detailed development guidance.
This README uses cogapp to auto-generate project listings.
uvx --from cogapp cog -r README.md practice/README.md archive/README.mdSummaries are cached in _summary.md files. Delete a summary to regenerate it.
These listings are also regenerated automatically every Monday by the
readme-refresh-weekly Temporal schedule (packages/temporal), which runs the
same cog -r and opens a PR if anything drifted.