This repository implements a 'Repository Harness'—a Rust-based CLI framework designed to make software codebases legible and operable for AI agents. It functions as a control plane for agent-assisted development, managing project state (stories, decisions, traces) through a combination of Git-native documents and a durable SQLite layer. The system enforces architectural rules and invariants via mechanical validation rather than process bureaucracy, distinguishing between a generic 'Core' payload and product-specific 'Consumer' work (e.g., Symphony). Key capabilities include self-updating binaries, semantic changeset replay for auditability, and explicit agent skills for onboarding and auditing. Architecturally, the codebase follows a clean separation of concerns with a Rust workspace containing `harness` (core logic) and `harness-cli` (interface). It utilizes a repository pattern to decouple business logic from database access, implementing transactional logging via JSONL changesets that support idempotent replay. The tool manages its own lifecycle through a robust installer that supports cross-platform profiles (Core vs. Core+CLI) and handles file conflicts via deterministic three-way merges. Evidence capsules and epoch fencing ensure data integrity during agent interactions and state transitions. The project demonstrates a high level of engineering maturity through its focus on reproducibility and trust boundaries. It includes extensive documentation (ADRs, execution plans, stories) and a comprehensive test suite covering installer contracts, changeset rebuilds, and boundary checks. The separation of the 'Symphony' product into a distinct repository while retaining protocol primitives in the core highlights a mature approach to library vs. application boundaries.
Goca is a CLI tool for generating Go applications following Clean Architecture principles. It scaffolds complete projects with domain, usecase, repository, and handler layers, supporting multiple databases (PostgreSQL, MySQL, MongoDB, etc.) and protocols (HTTP, gRPC, CLI, worker). The tool includes safety mechanisms (dry-run, backup, force), dependency injection generation, middleware creation, and Model Context Protocol (MCP) integration for AI-assisted development. Its architecture emphasizes layer separation and dependency management, generating production-ready code with built-in validation, testing scaffolding, and CI/CD pipeline generation.
Jetpack Android Starter is a production-ready template for modern Android development built on Jetpack Compose and clean architecture principles. It provides a comprehensive foundation with feature modules for authentication, home, profile, and settings, integrated with Firebase for authentication, Firestore, and Crashlytics. The architecture follows a two-layer UI/Data pattern with Repository pattern, Hilt dependency injection, Room for local storage, DataStore for preferences, and WorkManager for background synchronization. UI is built with Compose Material 3, featuring custom reusable components and type-safe navigation using Kotlin Serialization. The template includes CI/CD via GitHub Actions, automated dependency updates, documentation generation, and performance optimizations like baseline profiles. It demonstrates strong engineering practices with clear separation of concerns, testable architecture, and reusable patterns that solve common Android development challenges.
Quotio is a macOS application for managing AI provider accounts and tracking quota usage. It follows a Clean Architecture with four layers: Domain (core models), Application (business logic), Infrastructure (platform services), and Presentation (SwiftUI UI). The app provides both Local Proxy Mode (running a local proxy server CLIProxyAPI) and Monitor Mode (quota-only tracking) for AI services like Claude, OpenAI Codex, GitHub Copilot, Antigravity, and others. Key features include OAuth authentication flows, secure credential storage (Keychain/YubiKey), menu bar integration, automatic updates via Sparkle, telemetry via PostHog, AI CLI tool configuration, and Cloudflare tunnel management. The application uses modern Swift concurrency, protocol-oriented programming, and actor-based state management.
This is a Kotlin Multiplatform application that provides a movie and TV show browsing experience across Android, iOS, Desktop, and Web platforms. The app fetches data from The Movie Database (TMDB) API and displays content including now playing movies, popular/top-rated/upcoming movies and TV shows, celebrity information, and search functionality. It follows MVVM architecture with Clean Architecture principles, using Koin for dependency injection, Kotlin Coroutines for asynchronous operations, Ktor for networking, and Compose Multiplatform for the UI layer. The application includes features like favorite management with local storage, genre filtering, and detailed views for movies, TV shows, and celebrities.
Threema Android is a secure messaging application with end-to-end encryption using NaCl/libsodium. It features a modular architecture following clean architecture principles with separation into app, domain, data, and common layers. The app uses MVVM with ViewModels and StateFlow/LiveData, dependency injection via Koin, and Kotlin coroutines for asynchronous operations. Key functionality includes text/media messaging, voice/video calls, group chats, polls, contact management, backup/restore, multi-device synchronization, and availability status indicators. The application supports multiple build variants for different distribution channels (Google Play, Huawei AppGallery, F-Droid, Threema Shop) and includes enterprise features for business users. It relies on SQLCipher for encrypted local storage, implements custom CSP/D2M protocols for server communication, and provides web client functionality for desktop access.
This repository implements a food ordering system using a microservices architecture with four services: customer, order, payment, and restaurant. It employs Domain-Driven Design, clean/hexagonal architecture, and patterns such as Saga for distributed transactions, Outbox for reliable messaging, and CQRS for separating commands and queries. Services communicate asynchronously via Kafka with Avro serialization. The system includes REST APIs for customer and order operations, and uses Spring Boot with JPA for persistence.
Nestify is a monorepo that provides a framework for building NestJS applications with a sample order management system demonstrating its use. The repository separates reusable framework capabilities (in packages/) from application-specific code (in apps/api/). The framework provides building blocks for DDD-style NestJS APIs including database integrations (Kysely, ClickHouse), messaging (BullMQ, NATS), caching (Redis/Redisson), observability, resilience patterns, and DDD primitives. The sample application implements an order management system with REST endpoints, PostgreSQL database, Redis integration, and Clean Architecture layers using CQRS pattern. The framework emphasizes separation of concerns, with explicit rules against placing business logic in framework packages.
This is an Android TV application that serves as a client for media servers (primarily Jellyfin). It implements a Clean Architecture with clear separation between Data, Domain, and Presentation layers, using Jetpack Compose for the UI, Hilt for dependency injection, and Kotlin Coroutines/Flow for asynchronous operations. The application provides a TV-optimized interface for browsing media libraries, playing content with support for multiple players (ExoPlayer and MPV), handling subtitles/audio tracks/video quality, and managing user preferences. Key features include offline caching, background synchronization, advanced video format support (HDR, Dolby Vision), and a polished user experience with animations and focus handling for TV remotes.
Geto is an Android application that allows users to apply specific device settings (like disabling Developer Options or USB debugging) when launching particular apps, and automatically revert those settings when exiting the app. The app follows a clean architecture with separate modules for presentation, domain, and data layers. It uses Jetpack Compose for UI, Hilt for dependency injection, and Kotlin Coroutines for asynchronous operations. Key features include creating app shortcuts that trigger settings changes, a foreground service to monitor system setting changes, and secure storage of app-specific configurations using Room database and DataStore. The application requires the WRITE_SECURE_SETTINGS permission to modify system settings, which must be granted via ADB or Shizuku.
This repository is a comprehensive educational course titled '.NET Web API Zero to Hero' by codewithmukesh. It contains over 50 independent ASP.NET Core Web API sample projects organized into modules covering fundamentals (minimal APIs, exception handling, logging), database management with EF Core (CRUD, migrations, interceptors, soft deletes, bulk operations, pagination), advanced API patterns (CQRS with MediatR, custom dispatcher, Result pattern, mapping benchmarks), performance and caching (in-memory, Redis, HybridCache, EF second-level cache), API security (JWT, refresh tokens, role/claims/policy/permission-based authorization, API keys, CORS, rate limiting), file handling (PDF invoice generation), architecture (Clean Architecture vs Vertical Slice), observability (health checks, structured logging), and background processing. Each sample is a self-contained, runnable project with minimal setup (often using in-memory databases) and includes extensive BenchmarkDotNet performance comparisons. The code is well-structured, follows modern .NET 10 patterns, and demonstrates production-quality implementations of cross-cutting concerns like global exception handling, validation pipelines, and caching strategies. While the repo is primarily a teaching resource, many components (custom CQRS dispatcher, Result pattern, EF Core interceptors, permission-based authorization) are genuinely reusable in other projects.
coca is a static code analysis and refactoring CLI tool written in Go, designed to assess code quality, detect bad smells, analyze dependencies, and support migration tasks (specifically Spring MVC to Spring Boot). It operates as a monolithic command-line application using the Clean Architecture pattern, with distinct layers for domain models, application logic, and infrastructure. The tool supports multiple languages including Java, Go, Python, JavaScript, TypeScript, and Groovy, leveraging ANTLR for parsing and generating ASTs for analysis. The system's primary function is to scan codebases for technical debt, architectural issues, and API definitions, outputting results in various formats (JSON, CSV, Graphviz). It includes features for bad smell detection (e.g., Long Method, Large Class), test smell analysis, and dependency usage evaluation. The architecture is modular, allowing individual analysis features to be executed independently, though the tool itself is a single binary. While the codebase demonstrates solid engineering practices with a clean separation of concerns and reusable domain models, it exhibits technical drift in its dependency ecosystem. The Go version specified (1.23) is ahead of current stable releases, and several core dependencies (e.g., spf13/cobra, gomega) are significantly outdated, creating a mismatch between the code's stated requirements and the available ecosystem versions. This suggests the project is either in a transitional state or relies on specific, potentially unstable, dependency versions.
This repository is a front-end todo list application built with Next.js and React, demonstrating clean (hexagonal) architecture principles. The codebase is organized into domain, application, and infrastructure layers, promoting separation of concerns and testability. The domain layer contains pure use cases and interfaces, making it highly reusable. The infrastructure layer provides implementations for localStorage and in-memory storage. The application layer uses React components to interact with the domain via use cases. Despite the strong architectural foundation, the project suffers from significant technical drift due to outdated dependencies (Next.js 11, React 17, TypeScript 4.4, etc.), indicating a lack of recent maintenance.
This repository is a comprehensive collection of iOS interview questions and answers (both Objective-C and Swift), accompanied by numerous standalone demo Xcode projects that illustrate specific concepts, architectures, and coding patterns. The dominant character is application because most demos are runnable iOS apps (MVVM, Redux, SwiftUI, Core Data, etc.), but the repo is hybrid as its primary purpose is educational reference rather than a single production system. The codebase is fragmented across many independent projects with varying quality, some using older toolchains. Key reusable assets include a protocol-oriented networking package, an async image caching component, an observable binding helper, a mock URL protocol for tests, and Clean Swift Xcode templates.