Kaneo Commands for Development: Essential CLI Scripts Explained

The basic Kaneo commands are pnpm dev, pnpm build, pnpm lint, pnpm test, and pnpm typecheck, all defined in the root package.json and orchestrated by TurboRepo.

Kaneo is structured as a pnpm monorepo managed by TurboRepo. All development workflows—starting servers, building for production, running tests, and code quality checks—are exposed as npm scripts in the repository's top-level package.json. These commands coordinate tasks across the apps/ and packages/ directories, enabling parallel execution with correct environment variable propagation.

Essential Kaneo Development Commands

These core commands handle day-to-day development tasks. Each invokes TurboRepo to run operations across the workspace efficiently.

pnpm dev — Start Development Servers

Starts both the API server (@kaneo/api) and the web client (@kaneo/web) in watch mode with hot reloading. This is the primary command for local development.

pnpm dev

Defined in [package.json](https://github.com/usekaneo/kaneo/blob/main/package.json#L5-L8), this script uses TurboRepo to parallelize the startup process.

pnpm build — Production Build

Runs a production build for every workspace package, generating optimized bundles for deployment.

pnpm build

This command processes all packages in dependency order, ensuring shared libraries build before apps that depend on them.

pnpm lint — Code Quality with Biome

Executes Biome linting across the entire repository, automatically fixing style issues where possible.

pnpm lint

Biome provides fast, unified formatting and linting without requiring separate Prettier and ESLint configurations.

pnpm test — Unit Test Suite

Runs all unit tests defined across packages (API, web, and shared libraries).

pnpm test

pnpm test:integration — API Integration Tests

Executes the integration test suite for the API. Requires a running PostgreSQL instance.

pnpm test:integration

This command is defined in [package.json](https://github.com/usekaneo/kaneo/blob/main/package.json#L15) and validates end-to-end API functionality.

pnpm typecheck — TypeScript Validation

Performs a full TypeScript type-check across the workspace to catch type errors before commits.

pnpm typecheck

Found in [package.json](https://github.com/usekaneo/kaneo/blob/main/package.json#L16), this ensures type safety without emitting compiled files.

Internationalization Commands

Kaneo includes dedicated scripts for managing translation files, located in [package.json](https://github.com/usekaneo/kaneo/blob/main/package.json#L8-L12).

• pnpm i18n:check — Validates translation files for missing keys or formatting problems
• pnpm i18n:check:fix — Same validation with automatic fixes applied
• pnpm i18n:report — Generates statistics and identifies unused translation keys
• pnpm i18n:report:fix — Generates report with automatic cleanup
• pnpm i18n:schema — Recreates the i18n schema and formats with Biome

# Validate translations

pnpm i18n:check

# Fix translation issues automatically

pnpm i18n:check:fix

# Regenerate schema

pnpm i18n:schema

Configuration Files Behind Kaneo Commands

Understanding these files helps troubleshoot command behavior:

File	Purpose
[package.json](https://github.com/usekaneo/kaneo/blob/main/package.json)	Central script registry defining all available commands
[turbo.json](https://github.com/usekaneo/kaneo/blob/main/turbo.json)	TurboRepo pipeline configuration orchestrating task dependencies and caching
[ENVIRONMENT_SETUP.md](https://github.com/usekaneo/kaneo/blob/main/ENVIRONMENT_SETUP.md)	Documents required environment variables (KANEO_API_URL, KANEO_CLIENT_URL, etc.)
apps/api/	Hono/Node API implementation started by development commands
apps/web/	React + Vite web client started by development commands

Common Kaneo Command Workflows

Daily Development Cycle

# 1. Start both servers

pnpm dev

# 2. In another terminal, run type checks

pnpm typecheck

# 3. Before committing, lint and test

pnpm lint
pnpm test

Pre-Deployment Verification

# Full validation pipeline

pnpm typecheck
pnpm test
pnpm test:integration  # if PostgreSQL available

pnpm build

Summary

• pnpm dev starts the API and web client simultaneously with hot reloading
• pnpm build creates production-ready bundles across all packages
• pnpm lint runs Biome for unified formatting and linting
• pnpm test and pnpm test:integration execute unit and integration tests
• pnpm typecheck validates TypeScript types workspace-wide
• i18n commands manage translation file validation and schema generation
• All commands are defined in package.json and orchestrated by TurboRepo via turbo.json

Frequently Asked Questions

What package manager does Kaneo require?

Kaneo requires pnpm. The repository uses pnpm workspaces for monorepo management, and all documented commands assume pnpm is installed.

Why does Kaneo use TurboRepo instead of running scripts directly?

TurboRepo provides intelligent task orchestration with parallel execution, dependency-aware ordering, and aggressive caching. This means pnpm build automatically builds shared packages before apps that depend on them, and repeated builds skip unchanged packages entirely.

Where are the actual API and web applications located?

The API server code lives in apps/api/ and the web client in apps/web/. When you run pnpm dev, TurboRepo starts both applications and manages their interdependencies, environment variables, and port allocations as configured in turbo.json.

Do I need special environment variables for Kaneo commands to work?

Yes. Commands that start servers or run integration tests require environment variables documented in [ENVIRONMENT_SETUP.md](https://github.com/usekaneo/kaneo/blob/main/ENVIRONMENT_SETUP.md), including KANEO_API_URL, KANEO_CLIENT_URL, and PostgreSQL connection details for integration tests.

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