v0.15.2 Production Release • 100% Type-Safe Headless PM

The Headless Project Management Engine

Build custom project boards, dynamic DAG dependency trackers, and reactive Kanban workflows into your web apps. No bloated Jira or Linear iframes. Zero vendor lock-in.

$ pnpm add @critical-path/core @critical-path/client

Explore Documentation → Star on GitHub

Next.js App Router SvelteKit React Hooks Svelte 5 Runes SQLite & Firestore Web Fetch API TypeScript First

Interactive Live Demonstration

Real-Time Critical Path DAG Calculation

Click tasks to toggle completion. Watch downstream blockers dynamically resolve and the critical path recalculate.

Critical Path Duration

14 Hours

Unblocked Tasks

1 / 4

Engine Event Bus Log

[info] Initialized CriticalPathEngine with SQLite store

[calc] Topological sort computed: TASK-01 → TASK-02 → TASK-03 → TASK-04 (14h)

[event] Task TASK-01 started (active unblocked node)

Core Capabilities

Engineered for Modern Web Architecture

Everything you need to orchestrate complex task workflows, dependencies, and project state without heavy monolithic bloat.

🧩 Modular

100% Headless Architecture

Completely decoupled logic and state. Build your UI using React, Svelte, Vue, or vanilla HTML without fighting opinionated design systems.

⚡ High Performance

Real-time DAG & Critical Path

Automated topological sorting, cycle detection, and sub-millisecond calculation of critical path duration and blocker chains.

🗄️ Multi-Database

Pluggable Storage Adapters

Switch between SQLite, Firestore, or In-Memory storage with a single line of configuration. Or easily roll your own custom adapter.

🔌 Event-Driven

Extensible Lifecycle Hooks

Tap into async hooks: beforeTaskCreate, afterTaskUpdate, onStatusTransition. Add audit logging, webhook notifications, and automated workflows.

🌐 Universal

Standards-Compliant Web Fetch

Built on standard Web Request/Response objects. Mount seamlessly into Next.js App Router, SvelteKit, Express, or Cloudflare Workers.

🤖 MCP & AI

Model Context Protocol & WebMCP

First-class dual AI integration: standard server MCP for Claude Desktop & Cursor, plus client-side WebMCP with ambient project scoping for React and Svelte 5.

Effortless Integration

Drop-In Simplicity Across Frameworks

Clean, idiomatic APIs tailored for your favorite frontend and backend ecosystems.

// app/api/critical-path/[...path]/route.ts
import { createNextHandler } from '@critical-path/server';
import { SQLiteStore } from '@critical-path/core';

// Initialize store and mount standard Next.js route handler
const store = new SQLiteStore({ filename: 'critical-path.db' });
const handler = createNextHandler({ store });

export {
  handler as GET,
  handler as POST,
  handler as PUT,
  handler as PATCH,
  handler as DELETE,
  handler as OPTIONS
};

// src/routes/api/critical-path/[...path]/+server.ts
import { createSvelteKitHandler } from '@critical-path/server';
import { SQLiteStore } from '@critical-path/core';

const store = new SQLiteStore({ filename: 'critical-path.db' });
const handler = createSvelteKitHandler({ store });

export const GET = handler;
export const POST = handler;
export const PUT = handler;
export const PATCH = handler;
export const DELETE = handler;
export const OPTIONS = handler;

// components/ProjectBoard.tsx
import { CriticalPathProvider, useTasks, useKanban } from '@critical-path/react';

export function ProjectBoard({ projectId }: { projectId: string }) {
  const { tasks, loading, updateTaskStatus } = useTasks({ projectId });
  const { columns, moveTask } = useKanban({ projectId });

  if (loading) return <div>Calculating critical path...</div>;

  return (
    <div className="grid grid-cols-3 gap-4">
      {columns.map(col => (
        <KanbanColumn key={col.id} column={col} onDrop={moveTask} />
      ))}
    </div>
  );
}

<!-- components/TaskMonitor.svelte -->
<script lang="ts">
  import { createCriticalPathClient, createTaskState } from '@critical-path/svelte';

  const client = createCriticalPathClient({ baseUrl: '/api/critical-path' });
  const taskState = createTaskState(client, 'proj-alpha');
</script>

<div class="space-y-2">
  {#each $taskState.tasks as task}
    <div class="p-3 rounded border">
      <span>{task.title}</span>
      <span class="badge">{task.status}</span>
    </div>
  {/each}
</div>

// Choose SQLite (local/edge) or Firestore
import { CriticalPathEngine, SQLiteStore, FirebaseStore } from '@critical-path/core';
import { getFirestore } from 'firebase-admin/firestore';

// Option A: SQLite (file or in-memory)
const sqliteStore = new SQLiteStore({ filename: './critical-path.db' });

// Option B: Firestore (scalable NoSQL)
const firebaseStore = new FirebaseStore({ db: getFirestore() });

// Instantiate the Engine
export const engine = new CriticalPathEngine({ store: firebaseStore });

// Option A: Run MCP server for Claude Desktop / Cursor CLI
$ npx @critical-path/mcp --db ./app.db

// Option B: In-browser WebMCP tool registration for AI copilots
import { useWebMCP } from '@critical-path/react';

function ProjectView({ projectId }) {
  // Exposes ambient project actions to document.modelContext
  const { registered, tools } = useWebMCP({
    projectId,
    tools: ['create_task', 'list_tasks', 'update_task']
  });

  return <div>AI Copilot Active ({tools.length} actions)</div>;
}

Headless vs Monolithic

Why Headless Project Management?

Traditional project trackers force you into their web UI, vendor lock-in, and costly per-seat pricing. Critical Path gives you the raw engine to embed directly into your stack.

Traditional Monoliths (Jira, Asana, Monday)

× Rigid UI: Locked into third-party dashboards and iframe embeds.
× Siloed Data: Your project data lives in their proprietary cloud database.
× Per-Seat Tax: Exponential enterprise billing for every internal user.
× Slow Latency: Multi-second roundtrips across bloated external REST APIs.

The Critical Path Way

✓ 100% Custom UX: Render natively in your own React or Svelte design system.
✓ Your Database: Store tasks in your SQLite or Firestore instance alongside your application data.
✓ MIT Open Source: Zero per-seat fees. Deploy everywhere with complete source control.
✓ Sub-Millisecond Engine: In-process topological sorting and instant critical path math.