Yosemite-Crew

Open-Source Operating System for Animal Health

Yosemite Crew
A veterinary PIMS at the core. Connected apps, integrations, and community skills around it.
Built for veterinary teams, the families they care for, and the developers extending both.

Website · User skills · Developer setup · Contribute · Community

Product Walkthrough

https://github.com/user-attachments/assets/3f26baf9-5012-4026-90f9-bf64fc40284d

Code Quality (SonarCloud)

Metric	Backend	Platform (Frontend)	Mobile App	Desktop
Quality Gate
Coverage
Bugs
Code Smells
Reliability
Security Rating
Vulnerabilities
Duplicated Lines

Contents

• Overview
• Who It Is For
• Skills for Users
• Architecture
• Repository Map
• Our Tech Stack
• Local Development
• Security and Quality
• Documentation
• Current capabilities
• Contributing and Community
• License

Overview

Yosemite Crew is an open-source operating system for animal health, with a veterinary Practice Information Management System (PIMS) at its core.

• Practice operations: scheduling, tasks, inventory, billing, and communications.
• Clinical workflows: patient records, forms, and connected laboratory workflows.
• Pet-owner experience: appointments, records, and communication with participating practices.
• Developer access: inspect and extend the source, use documented REST and FHIR-oriented interfaces, or connect a compatible client to the optional MCP server.

Who It Is For

Veterinary Teams

Manage appointments, clinical records, inventory, billing, and client messages in the web or desktop PIMS. Use the community skills to compare software, onboard staff, audit exports, and review practice workflows.

Pet Owners

Access appointments, records, and messages through participating practices in the mobile app. Use the visit-preparation skill to organize observations and questions before an appointment.

Developers

Extend the apps, build REST/FHIR integrations, or query the developer API through the read-only MCP server. Start with the repository map, local setup, and contributor guide.

Skills for Users

Use these seven skills in your AI assistant without a Yosemite Crew account, API key, or server. They contain instructions and reference files, not executable scripts or service connectors.

Choose a Skill

Get Started

1. Open a skill folder and read SKILL.md.
2. Install the whole folder, including references/ and agents/, using the instructions below. Compare versions before replacing an existing copy.
3. Invoke the skill with your requested output and the relevant redacted documents. Copy only the user skills you need, not the repository’s engineering skills.

Example Requests

For slash-command assistants, replace $skill-name with /skill-name.

Before signing a software agreement:

Use $yosemite-vet-software-buyer to review this redacted agreement.
Check renewal terms, extra fees, data-export rights, and exit costs.
Separate confirmed clauses from unanswered questions. Favor no supplier.

For a practice stock review:

Use $yosemite-inventory-planning to review this stock sheet.
Flag expiry exposure and missing unit or lead-time information.
Draft a reorder list for review. Do not place orders.

Before a veterinary appointment:

Use $yosemite-vet-visit-prep to organize my observations and questions
into a short brief for my veterinarian. Do not diagnose or suggest
medication changes.

Independence, Privacy, and Limits

• Vendor neutrality: evaluate all suppliers, including Yosemite Crew, by the same criteria. Keeping your existing software or buying nothing remains an option; no sales call is required.
• Unverified information: flag missing facts and approvals rather than inventing them. Review drafts before operational use.
• Professional review: clinical content needs veterinary review; contracts and regulatory questions need qualified advice. Do not delay urgent veterinary care to prepare a brief.
• Authorization: obtain separate approval before sending messages, placing orders, moving records, or signing agreements. Skills do not authorize medication changes.
• Data handling: use only information you are authorized to share with the chosen AI service. Redact unnecessary identifiers and credentials, follow practice policy, and keep sensitive records out of public issues and pull requests.

Architecture

Persistence: Prisma owns the PostgreSQL schema and migrations in packages/database. Enforce application authorization and organization-scoped access when reading or writing practice data. See ADR 0001.

Interoperability: the router documentation lists supported REST/FHIR resources, operations, and authorization requirements.

Repository Map

This is a TypeScript monorepo managed with pnpm workspaces and Turborepo.

Applications

Shared Packages

Skills live in .agents/skills and .claude/skills. Contributor instructions are in CONTRIBUTING.md.

Our Tech Stack

• Language and workspace: TypeScript, pnpm workspaces, and Turborepo for shared code, dependency management, and task orchestration.
• Web: Next.js and React, with Zustand for client state; Storybook and Chromatic for component review, and Playwright for end-to-end and accessibility checks.
• Backend: Express, Socket.IO for realtime updates, and BullMQ backed by Redis for background work.
• Data: Supabase Postgres with Prisma for schema management, migrations, and database access.
• Authentication: SuperTokens behind the shared authentication package’s provider-neutral interface.
• Mobile: React Native, Redux Toolkit, and i18next, with native Android/iOS tooling and Detox for local end-to-end checks.
• Desktop: Electron, electron-builder, and electron-updater for the desktop application and its release packaging.
• Payments: Stripe integration for configured payment workflows.
• Cloud services: AWS S3 for object storage and SES for email; Pinpoint SDK is also listed in the backend dependencies.
• Clinical interoperability: FHIR R4 resource shapes alongside application REST endpoints; IDEXX laboratory integration and Merck Manuals / HealthLink content integration.
• AI integration: An optional read-only MCP server for developer API access, plus standalone user skills that do not require it.

Dependency manifests: web, backend, mobile, desktop, and lockfile. Configure provider accounts, credentials, and permissions before using Stripe, AWS, IDEXX, or Merck integrations.

Local Development

Contributions target dev; main is the release branch. For skills only, use skill installation instead.

1. Prepare the Toolchain

• Git
• Node.js 22, as specified in .nvmrc
• pnpm 8.15.6, pinned in package.json
• A dedicated development PostgreSQL database, Redis, and the authentication and external-service configuration required for the workflows you will run

2. Clone and Install

Contributors should fork first and substitute their fork URL in the clone command.

git clone --branch dev https://github.com/YosemiteCrew/Yosemite-Crew.git
cd Yosemite-Crew
pnpm install --frozen-lockfile

Dependency installation sets up the repository’s Git hooks. Keep secret scanning, formatting, commit-message checks, and pre-push checks enabled.

3. Configure Services

For a fresh checkout only, copy the example environment files and fill in the values required for your environment. Do not overwrite existing local files or commit secrets.

cp apps/backend/.env.example apps/backend/.env
cp apps/frontend/.env.example apps/frontend/.env

Configure PostgreSQL, Redis, authentication, and the integrations you will use. Make DATABASE_URL and DIRECT_URL available in the shell that runs Prisma commands; app-specific .env files are not automatically loaded by every workspace command. Never use production credentials for local setup.

Use separate PostgreSQL databases for the application and a self-hosted SuperTokens core. Stream chat is optional for local work: leaving its two server credentials blank keeps the API bootable and records the upload-policy control as skipped, while chat operations remain unavailable until configured.

Generate the Prisma client:

pnpm --filter @yosemite-crew/database run prisma:generate

Before applying migrations, follow the database setup and baseline guidance. Check migration history first for any existing or restored database.

The repository does not currently provide a Docker Compose setup. Use the pnpm workflow above and provision PostgreSQL and Redis separately.

4. Start the Web App and API

pnpm run dev --filter frontend --filter backend

The default web address is http://localhost:3000; the backend example uses port 4000. Keep API URLs and authentication origins consistent with your environment. To run one app, use pnpm --filter frontend run dev or pnpm --filter backend run dev.

pnpm --filter mobileAppYC run start

pnpm --filter mobileAppYC run android
# Or: pnpm --filter mobileAppYC run ios

5. Validate Your Changes

Follow CONTRIBUTING.md for the affected workspace’s checks and targeted tests. Root pnpm run lint and pnpm run type-check also run on pre-push.

pnpm run verify runs lint, type-check, tests, and builds. CI also checks security, accessibility, end-to-end workflows, and releases.

Security and Quality

Report suspected vulnerabilities privately through SECURITY.md, not in a public issue. Never include credentials, client records, or patient records in bug reports. Request development or staging access from maintainers through a secure channel.

Contribution requirements: engineering standards.

Documentation

Contributing and Community

Contributions can be code, documentation, tests, translations, or improvements to a user skill. Start with CONTRIBUTING.md, check existing issues, and target pull requests at dev.

For skill improvements, keep recommendations vendor-neutral, protect sensitive information, and use fictional or redacted examples. Keep corresponding .agents/skills and .claude/skills copies in sync, including their supporting files.

• Questions and discussion: Discord
• Project news: LinkedIn
• Community updates: Instagram and TikTok
• Source and releases: GitHub and release history

Thank you to everyone contributing code, reporting issues, improving documentation, and sharing the project.

License

Yosemite Crew is released under the GNU Affero General Public License v3.0, with a Yosemite Crew licensing exception that permits combining the program with works under CC-BY-3.0 and CC-BY-4.0.

The YOSEMITE CREW name, logo, and branding are not covered by the open-source license. Commercial use of the branding requires a separate commercial license. See License.txt for the full terms.