Dependencies for the Kaneo Project: Complete Monorepo Breakdown

The Kaneo project is a pnpm monorepo with dependencies split across the root workspace, API server (@kaneo/api), React frontend (@kaneo/web), and three shared packages (@kaneo/email, @kaneo/libs, @kaneo/permissions), requiring only pnpm install to resolve the entire dependency graph.

Kaneo is an open-source project management platform built as a pnpm monorepo that isolates dependencies per workspace. Understanding the dependencies for the Kaneo project is essential for contributors deploying the API server, customizing the React frontend, or extending shared libraries. Each workspace declares its own runtime and development dependencies in package.json files, enabling the entire project to install with a single command while maintaining a clean, scoped dependency graph.

Root Workspace Dependencies

The root [package.json](https://github.com/usekaneo/kaneo/blob/main/package.json) manages monorepo tooling and global configuration. It declares dotenv-mono ^1.5.1 as its sole production dependency for loading environment variables across all workspaces.

Development dependencies include:

• @biomejs/biome for linting and formatting
• turbo for task running and build orchestration
• husky for Git hooks management
• @commitlint/cli and @commitlint/config-conventional for commit message linting
• esbuild, typescript, linkifyjs, and tar-fs for build utilities

API Workspace Dependencies

Located in [apps/api/package.json](https://github.com/usekaneo/kaneo/blob/main/apps/api/package.json), the @kaneo/api workspace powers the backend Hono server with a focus on type safety and performance.

Core runtime dependencies include:

• hono for the web framework with @hono/node-server and @hono/node-ws
• drizzle-orm and pg for PostgreSQL database access
• better-auth with @better-auth/drizzle-adapter and @better-auth/api-key for authentication
• @hono/standard-validator for request validation

Infrastructure and integration dependencies include:

• @aws-sdk/client-s3 and @aws-sdk/s3-request-presigner for object storage
• octokit and @octokit/webhooks for GitHub integration
• @sentry/node for error tracking and monitoring
• ioredis for Redis connectivity
• @modelcontextprotocol/sdk for AI model context protocol support

Validation and utilities include valibot, zod, @valibot/to-json-schema, bcryptjs, @oslojs/crypto, @oslojs/encoding, @paralleldrive/cuid2, creem, and croner.

Development dependencies include vitest, @vitest/coverage-v8, drizzle-kit, tsx, @types/node, and @types/pg.

Example: AWS S3 Client Usage

// apps/api/src/utils/s3.ts
import { S3Client } from "@aws-sdk/client-s3";

const s3 = new S3Client({ region: process.env.AWS_REGION });
export default s3;

Reference: The @aws-sdk/client-s3 dependency is defined in [apps/api/package.json](https://github.com/usekaneo/kaneo/blob/main/apps/api/package.json).

Web Workspace Dependencies

The frontend workspace @kaneo/web defined in [apps/web/package.json](https://github.com/usekaneo/kaneo/blob/main/apps/web/package.json) runs on React 19 with TypeScript, utilizing modern data-fetching and UI primitives.

Framework and routing dependencies include:

• react and react-dom (version 19)
• @tanstack/react-router for type-safe routing
• @tanstack/react-query for server state management
• zustand for client state management

UI and editing dependencies include:

• @radix-ui/* primitives for accessible headless components
• @tiptap/* packages for rich text editing
• tailwindcss with @tailwindcss/vite for styling
• lucide-react for iconography
• shiki for syntax highlighting
• sonner for toast notifications

Utilities include clsx, date-fns, dompurify, immer, and @better-auth/api-key.

Development tooling includes vite, @rolldown/plugin-babel, @tailwindcss/postcss, @testing-library/react, jsdom, vitest, and internal workspace dependencies @kaneo/libs and @kaneo/permissions.

Example: Consuming Shared Libraries

// apps/web/src/components/TaskList.tsx
import { useTaskList } from "@/hooks/queries/tasks/useTaskList";
import { cn } from "@kaneo/libs";

export function TaskList() {
  const { data: tasks } = useTaskList();
  return (
    <ul className={cn("space-y-2", "p-4")}>
      {tasks?.map((t) => (
        <li key={t.id}>{t.title}</li>
      ))}
    </ul>
  );
}

Reference: The cn utility is provided by @kaneo/libs, referenced via the workspace protocol in [apps/web/package.json](https://github.com/usekaneo/kaneo/blob/main/apps/web/package.json).

Shared Package Dependencies

Three internal packages provide reusable logic consumed by both the API and web layers.

@kaneo/email

Located in [packages/email/package.json](https://github.com/usekaneo/kaneo/blob/main/packages/email/package.json), this package depends on nodemailer for SMTP transport and @react-email/components for type-safe email templates. It lists react and react-dom as peer dependencies for server-side email rendering.

@kaneo/libs

Found in [packages/libs/package.json](https://github.com/usekaneo/kaneo/blob/main/packages/libs/package.json), this utility package contains helper functions like the cn() class merger. It declares no runtime dependencies, keeping it lightweight for consumption by both API and web workspaces, though it includes development dependencies like hono and react for type checking.

@kaneo/permissions

Defined in [packages/permissions/package.json](https://github.com/usekaneo/kaneo/blob/main/packages/permissions/package.json), this authorization helper package depends on better-auth to align permission logic with the authentication system used throughout Kaneo.

Example: Sending Email from the API

// apps/api/src/email/sendWelcome.ts
import { render } from "@react-email/render";
import { WelcomeEmail } from "@kaneo/email/templates/WelcomeEmail";
import nodemailer from "nodemailer";

export async function sendWelcome(to: string) {
  const html = render(<WelcomeEmail userEmail={to} />);
  const transporter = nodemailer.createTransport({ /* transport config */ });
  await transporter.sendMail({ to, subject: "Welcome!", html });
}

Reference: The nodemailer and @react-email/components dependencies are declared in [packages/email/package.json](https://github.com/usekaneo/kaneo/blob/main/packages/email/package.json).

Installing the Monorepo

To resolve the complete dependency graph across all workspaces, run:

pnpm install

This command installs production and development dependencies for the root, API, web, and all shared packages simultaneously. The installation respects workspace links (using the workspace:* protocol) that tie the internal packages together, ensuring that @kaneo/email, @kaneo/libs, and @kaneo/permissions are correctly symlinked rather than fetched from a registry.

Summary

• The root workspace manages monorepo tooling including Turbo, Biome, Husky, and dotenv-mono for environment management.
• The API workspace (apps/api/package.json) relies on Hono, Drizzle ORM, Better-Auth, AWS SDK, Octokit, and Vitest for a type-safe backend.
• The Web workspace (apps/web/package.json) builds upon React 19, TanStack Router, Radix UI, Tiptap, and Vite for a modern frontend.
• Shared packages encapsulate email rendering (@kaneo/email), utility functions (@kaneo/libs), and permission logic (@kaneo/permissions).
• Run pnpm install from the repository root to resolve all dependencies across the monorepo.

Frequently Asked Questions

What package manager does Kaneo use?

Kaneo uses pnpm as its package manager, leveraging workspace features to manage the monorepo structure. The pnpm-workspace.yaml file defines the workspace boundaries, allowing dependencies to be installed recursively across apps/* and packages/* directories with a single pnpm install command.

How does Kaneo handle environment variables across workspaces?

The root workspace depends on dotenv-mono ^1.5.1 to load environment variables from .env files and propagate them to child workspaces. This ensures consistent configuration across the API server and web frontend without duplicate environment management code in each package.

Which authentication library does Kaneo depend on?

Both the API and web workspaces depend on Better-Auth, with the API specifically including @better-auth/drizzle-adapter for PostgreSQL integration via Drizzle ORM. The @kaneo/permissions shared package also lists better-auth as a dependency to maintain type-safe authorization logic aligned with the authentication system.

What testing frameworks are included in Kaneo dependencies?

The project uses Vitest for unit testing in both the API and web workspaces, with @vitest/coverage-v8 for code coverage reporting. The web workspace additionally includes @testing-library/react and jsdom for component testing, while the API relies on @types/node and native Vitest assertions for backend test suites.

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