Main Dependencies for the Kaneo Repository: Complete Tech Stack Guide

The Kaneo repository is a pnpm monorepo built with Hono for the backend API, React 19 with TanStack Query for the frontend, and Drizzle ORM for database operations, managed within a Turbo-powered workspace using Better Auth for security and Tailwind CSS v4 for styling.

The kaneo repository (available at usekaneo/kaneo) is an open-source project that organizes its codebase as a pnpm workspace. Understanding the main dependencies for the kaneo repository requires examining the package.json files distributed across the backend API, React frontend, and shared internal packages.

Backend API Dependencies

The backend service, defined in apps/api/package.json, relies on a minimal, high-performance stack designed for Edge compatibility and type safety.

Hono Web Framework and Routing

The API is built on @honojs/hono, a lightweight web framework that provides the core HTTP server functionality. This is supplemented by hono-openapi, which supplies OpenAPI decorators for automatic route documentation generation. The combination creates a fast, documented API surface with minimal overhead.

Database and Authentication

Data persistence relies on drizzle-orm, a type-safe PostgreSQL ORM that allows SQL-like queries in TypeScript. Authentication and session management are handled by better-auth, which integrates with the ORM layer. For validation, the API uses valibot alongside Zod for schema definition and input sanitization.

Utility Libraries

Unique identifier generation is handled by @paralleldrive/cuid2, providing collision-resistant CUIDs for database records. These utilities are imported throughout the API source files to ensure consistent data handling.

import { Hono } from "hono";
import { validator } from "hono-openapi";
import * as v from "valibot";
import { db } from "./db";
import { projects } from "./schema";

const app = new Hono()
  .get(
    "/projects/:id",
    validator("param", v.object({ id: v.string() })),
    async (c) => {
      const { id } = c.req.valid("param");
      const project = await db.select().from(projects).where(eq(projects.id, id));
      return c.json(project);
    },
  );

export default app;

Frontend Web Dependencies

The web application, located in apps/web/package.json, utilizes a modern React 19 stack focused on performance and developer experience.

Core React Ecosystem

The UI is powered by react version 19 and react-dom for rendering. Routing is implemented via @tanstack/router, which provides file-based routing conventions similar to modern meta-frameworks.

State and Data Management

Server state synchronization is handled by @tanstack/react-query, which manages caching, background updates, and data fetching. For global client-side state, the application uses zustand, a lightweight state management solution that avoids the boilerplate of larger alternatives.

UI Components and Styling

Interface components are built using radix-ui primitives, providing unstyled, accessible building blocks that comply with WAI-ARIA standards. Styling is implemented with tailwindcss version 4, utilizing its utility-first approach for rapid UI development.

import { useQuery } from "@tanstack/react-query";
import { getProject } from "@/fetchers/project";

export function useProject(id: string) {
  return useQuery({
    queryKey: ["project", id],
    queryFn: () => getProject(id),
    staleTime: 5 * 60_000,
  });
}

export function Card({ children }: { children: React.ReactNode }) {
  return (
    <div className="rounded-lg bg-white shadow-md p-4 hover:shadow-lg transition-shadow">
      {children}
    </div>
  );
}

Shared Workspace Packages

The monorepo structure includes internal packages that share code between the API and web layers:

• @kaneo/libs: Core utilities defined in packages/libs/package.json and consumed by both frontend and backend
• @kaneo/email: Email helper utilities for transactional notifications
• @kaneo/permissions: Centralized permission logic for access control

These packages are referenced in the root package.json workspace configuration and imported using TypeScript path mapping to eliminate code duplication across the repository.

Development and Build Tooling

The repository workflow is orchestrated by several critical dev dependencies:

• pnpm: The workspace-aware package manager configured via pnpm-workspace.yaml to link apps/* and packages/*
• turbo: A high-performance task runner that caches build outputs across the monorepo
• biome: A unified linter and formatter that replaces ESLint and Prettier
• vitest: The test runner for both unit and integration testing

These tools ensure consistent code quality and fast build times across the entire workspace, from the API in apps/api/ to the web interface in apps/web/.

Summary

• The kaneo repository organizes code as a pnpm monorepo with dedicated workspaces for the API, web frontend, and shared libraries.
• Backend dependencies center on Hono for the HTTP framework, Drizzle ORM for database operations, and Better Auth for security.
• Frontend dependencies include React 19, TanStack Query for server state, Zustand for client state, and Tailwind CSS v4 for styling.
• Shared packages (@kaneo/libs, @kaneo/email, @kaneo/permissions) provide centralized utilities referenced in both apps/api/package.json and apps/web/package.json.
• Development tooling leverages pnpm, Turbo, Biome, and Vitest for monorepo task running and code quality.

Frequently Asked Questions

What package manager does the kaneo repository use?

The kaneo repository uses pnpm as its package manager, configured as a monorepo via pnpm-workspace.yaml. This setup defines workspace packages in apps/* and packages/*, enabling efficient dependency deduplication and cross-package imports between the API and frontend.

How does the kaneo backend handle database operations?

The backend uses drizzle-orm for type-safe PostgreSQL interactions, as specified in apps/api/package.json. This ORM allows the API to write SQL-like queries in TypeScript with compile-time type safety, working alongside @paralleldrive/cuid2 for generating unique identifiers.

Why does the kaneo frontend use both TanStack Query and Zustand?

@tanstack/react-query manages server-state synchronization, caching, and background refetching of API data, while zustand handles global client-side UI state. This separation follows modern React patterns by keeping remote data logic distinct from local interface state.

What is the purpose of the hono-openapi dependency?

hono-openapi provides decorators and validators that integrate with the Hono framework to generate OpenAPI specifications automatically. This dependency allows the apps/api routes to self-document, producing API schemas directly from the TypeScript code and validation logic defined with valibot.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}