@causari/mcp-server 0.1.2 → 0.1.4

package/dist/cli.js

@@ -1,28 +1,37 @@
 #!/usr/bin/env node
-/**
- * Causari MCP Server — local CLI.
- *
- * Usage:
- *   causari-mcp                    # stdio transport (for Claude Code, Cursor)
- *   npx @causari/mcp-server        # same, no install
- *
- * Configure in Claude Code .mcp.json:
- *   {
- *     "mcpServers": {
- *       "causari": { "command": "causari-mcp" }
- *     }
- *   }
- */
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { createCausariServer } from './server.js';
+import {
+  createCausariServer
+} from "./chunk-HQIPIA5N.js";
+import "./chunk-KBU67SEH.js";
+
+// src/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function resolvePack(argv) {
+  const flag = argv.indexOf("--pack");
+  if (flag >= 0 && argv[flag + 1]) return argv[flag + 1];
+  const eq = argv.find((a) => a.startsWith("--pack="));
+  if (eq) return eq.slice("--pack=".length);
+  return process.env.CAUSARI_PACK || void 0;
+}
 async function main() {
-    const server = createCausariServer();
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // Server now runs until stdin closes.
+  const pack = resolvePack(process.argv.slice(2));
+  let server;
+  try {
+    server = createCausariServer({ pack });
+    if (pack) process.stderr.write(`causari-mcp: loaded pack "${pack}" alongside the core CKG
+`);
+  } catch (err) {
+    process.stderr.write(
+      `causari-mcp: ${err instanceof Error ? err.message : String(err)} \u2014 serving core CKG only
+`
+    );
+    server = createCausariServer();
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
 }
 main().catch((err) => {
-    process.stderr.write(`causari-mcp fatal: ${err instanceof Error ? err.stack : String(err)}\n`);
-    process.exit(1);
+  process.stderr.write(`causari-mcp fatal: ${err instanceof Error ? err.stack : String(err)}
+`);
+  process.exit(1);
 });
-//# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -1,3 +1,247 @@
-export { createCausariServer } from './server.js';
-export { ALL_TOOLS } from './tools.js';
-//# sourceMappingURL=index.d.ts.map
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+/**
+ * Causal Knowledge Graph — Core Types
+ *
+ * Schema version 1.0.
+ *
+ * Three core entities:
+ *  - CKGEvent: a node on the timeline (something that happened or will happen)
+ *  - CausalLink: a directed edge between two events with relationship type + confidence
+ *  - Insight: a derived pattern that links similar causal chains across time
+ */
+type Domain = 'technology' | 'humanities' | 'systems' | 'science' | 'economy' | 'geopolitics' | 'philosophy' | 'environment' | 'culture' | 'health' | 'other';
+type Precision = 'millennium' | 'century' | 'decade' | 'year' | 'month' | 'day';
+type CausalRelationship = 'caused' | 'enabled' | 'accelerated' | 'delayed' | 'prevented' | 'inspired';
+type Scope = 'world' | 'personal' | 'org';
+/**
+ * Lifecycle status for a live/daily event (e.g. a World Cup fixture).
+ *
+ * Only meaningful for events that carry the optional live-event fields below.
+ * `completed` = it happened; `scheduled` = a future fixture not yet played;
+ * `live` = in progress right now; `forecast` = a speculative/projected event.
+ * Historical CKG events leave `status` undefined.
+ */
+type LiveStatus = 'completed' | 'scheduled' | 'live' | 'forecast';
+type SourceType = 'wikipedia' | 'wikidata' | 'academic' | 'news' | 'user' | 'ai-inferred' | 'demo-seed';
+interface Source {
+    type: SourceType;
+    url?: string;
+    citation?: string;
+    /** 0-1 reliability score */
+    reliability: number;
+}
+/**
+ * A node on the timeline. Can be historical (yearNum < 0 for BCE), present, or future.
+ */
+interface CKGEvent {
+    /** Stable identifier, kebab-case. e.g. "industrial-revolution" */
+    id: string;
+    /** Short display name */
+    title: string;
+    /** Longer description — explains what happened and why it matters */
+    description: string;
+    /**
+     * Numeric year. Negative = BCE. Use Number.POSITIVE_INFINITY for omega (heat death of universe).
+     * For sub-year precision, use timestamp field.
+     */
+    yearNum: number;
+    /**
+     * Display label for the year. e.g. "1969", "-3500", "70k BCE", "∞"
+     */
+    yearLabel: string;
+    /** Optional Unix epoch in ms for sub-year precision (post-1970 events) */
+    timestamp?: number;
+    /** Granularity of yearNum — controls UI rendering and query bucketing */
+    precision: Precision;
+    /** Knowledge domains this event belongs to */
+    domains: Domain[];
+    /**
+     * 0-1, weighted by causal connections + cultural significance.
+     * Used to filter for major events when zoomed out or when minImpact is set.
+     */
+    impactScore: number;
+    /** Evidence for this event's existence and properties */
+    sources: Source[];
+    /** Optional Wikidata Q-id for entity linking */
+    wikidataId?: string;
+    /** Tier scope — controls visibility */
+    scope: Scope;
+    /** For org-scoped events: tenant identifier */
+    orgId?: string;
+    /** For personal-scoped events: user identifier */
+    userId?: string;
+    /**
+     * Free-form tags for search and filtering.
+     * Examples: ["AI", "watershed", "infrastructure"]
+     */
+    tags: string[];
+    /**
+     * Confidence score for forecasted/predicted events. 0-1.
+     * Undefined = certain (historical fact).
+     */
+    forecastConfidence?: number;
+    /** Reasoning trace for forecasted events */
+    forecastReasoning?: string;
+    /**
+     * ISO calendar date (YYYY-MM-DD) — the primary x-axis key for a day-scale
+     * timeline. Use alongside `precision: 'day'`. Distinct from `yearNum`, which
+     * stays the coarse numeric anchor for the cosmic timeline.
+     */
+    date?: string;
+    /** Human-readable date label, e.g. "June 14, 2026". */
+    dateLabel?: string;
+    /**
+     * Lifecycle status of a live event. Drives card styling on the daily feed.
+     * Undefined for historical/static events.
+     */
+    status?: LiveStatus;
+    /**
+     * Named real-world entities involved (teams, groups, venues), e.g.
+     * ["Mexico", "Group A", "Estadio Azteca"]. Rendered as tag chips.
+     */
+    entities?: string[];
+    /**
+     * The headline causal line shown on the card — why this result/fixture
+     * matters to the wider tournament. One or two sentences.
+     */
+    whyItMatters?: string;
+    /**
+     * Free-text hints about what to watch next (upcoming fixtures, table
+     * implications). Rendered as the card footer.
+     */
+    nextWatchpoints?: string[];
+}
+/**
+ * Directed causal edge between two events.
+ */
+interface CausalLink {
+    id: string;
+    /** Cause event id */
+    fromEvent: string;
+    /** Effect event id */
+    toEvent: string;
+    relationship: CausalRelationship;
+    /** 0-1 confidence in this causal claim */
+    confidence: number;
+    /**
+     * Human-readable explanation of WHY this link exists.
+     * e.g. "Steam power required iron-working precision developed in the prior century"
+     */
+    evidence: string;
+    sources: Source[];
+    /** Attribution — where this link came from */
+    contributedBy: 'system' | 'ai-inferred' | 'community' | 'expert' | string;
+    /** Has this link been validated by community/expert review? */
+    validated: boolean;
+    /** Optional tenant scoping for org links */
+    scope: Scope;
+    orgId?: string;
+    userId?: string;
+}
+/**
+ * A derived pattern recognised across multiple causal chains.
+ *
+ * Example: "Information democratization cycle" — the pattern observed in
+ * Gutenberg→Reformation, Internet→Arab Spring, LLMs→? .
+ */
+interface Insight {
+    id: string;
+    /** Short pattern name */
+    pattern: string;
+    /** Longer description of the pattern */
+    description: string;
+    /** Causal links that demonstrate this pattern */
+    instances: string[];
+    /** 0-1 — how useful is this pattern for prediction? */
+    predictiveValue: number;
+    /** Optional contextual domains where this pattern applies */
+    domains: Domain[];
+    contributedBy: 'system' | 'ai-inferred' | 'community' | 'expert' | string;
+}
+/**
+ * Aggregate snapshot of CKG state — what an MCP query returns when caller asks for graph stats.
+ */
+interface CKGStats {
+    eventCount: number;
+    causalLinkCount: number;
+    insightCount: number;
+    domains: Record<Domain, number>;
+    scope: Scope;
+    lastUpdated: string;
+}
+
+/**
+ * In-memory CKG store. Indexes events and links for fast traversal.
+ *
+ * For MVP this is in-memory only. Future: back with Cloudflare D1 or Postgres.
+ * The Store interface stays the same; only the implementation swaps.
+ */
+
+declare class CKGStore {
+    private events;
+    private links;
+    private insights;
+    private outgoing;
+    private incoming;
+    constructor(seed?: {
+        events?: CKGEvent[];
+        causalLinks?: CausalLink[];
+        insights?: Insight[];
+    });
+    addEvent(e: CKGEvent): void;
+    addLink(l: CausalLink): void;
+    addInsight(i: Insight): void;
+    getEvent(id: string): CKGEvent | undefined;
+    getLink(id: string): CausalLink | undefined;
+    getInsight(id: string): Insight | undefined;
+    /**
+     * All outgoing causal links from a given event (this event as cause).
+     * Filtered by minConfidence if provided.
+     */
+    outgoingFrom(eventId: string, minConfidence?: number): CausalLink[];
+    /**
+     * All incoming causal links into a given event (this event as effect).
+     */
+    incomingTo(eventId: string, minConfidence?: number): CausalLink[];
+    allEvents(): CKGEvent[];
+    allLinks(): CausalLink[];
+    allInsights(): Insight[];
+    stats(scope?: Scope): CKGStats;
+}
+
+/**
+ * Causari MCP Server core.
+ *
+ * Wires CKGStore + tool handlers to the MCP protocol. Transport-agnostic;
+ * cli.ts attaches the stdio transport.
+ */
+
+declare function createCausariServer(opts?: {
+    store?: CKGStore;
+    pack?: string;
+}): Server;
+
+/**
+ * MCP tool definitions for Causari.
+ *
+ * Each tool wraps a CKG query function and shapes the result for LLM consumption.
+ * Output shape priorities:
+ *  1. Token-efficient — drop redundant fields
+ *  2. Self-explanatory — include relationship + evidence so LLM doesn't need to re-query
+ *  3. Calibrated — surface confidence + sources so LLM can communicate uncertainty
+ */
+
+interface ToolDef {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    handler: (args: Record<string, unknown>, store: CKGStore) => unknown;
+}
+declare const ALL_TOOLS: ToolDef[];
+
+export { ALL_TOOLS, createCausariServer };

package/dist/index.js

@@ -1,3 +1,10 @@
-export { createCausariServer } from './server.js';
-export { ALL_TOOLS } from './tools.js';
-//# sourceMappingURL=index.js.map
+import {
+  createCausariServer
+} from "./chunk-HQIPIA5N.js";
+import {
+  ALL_TOOLS
+} from "./chunk-KBU67SEH.js";
+export {
+  ALL_TOOLS,
+  createCausariServer
+};

package/dist/smoke.js

@@ -1,176 +1,150 @@
-/**
- * Smoke test — verifies the 5 tool handlers return sensible results
- * against the seed CKG data. Run: node dist/smoke.js
- */
-import { CKGStore, loadSeed } from '@causari/ckg';
-import { ALL_TOOLS } from './tools.js';
-const store = new CKGStore(loadSeed());
-const stats = store.stats();
-console.log('CKG stats:', stats);
-const tests = [
-    {
-        tool: 'query_events',
-        args: { query: 'printing', limit: 5 },
-        expect: (r) => r.events?.length > 0 && r.events[0].id === 'printing'
-            ? null
-            : `expected printing event, got ${JSON.stringify(r.events?.[0])}`,
-    },
-    {
-        tool: 'query_events',
-        args: { yearFrom: 1900, yearTo: 2000, minImpact: 0.85 },
-        expect: (r) => r.events?.every((e) => e.yearNum >= 1900 && e.yearNum <= 2000 && e.impactScore >= 0.85)
-            ? null
-            : 'year/impact filter failed',
-    },
-    {
-        tool: 'query_events',
-        args: { domains: ['technology'], minImpact: 0.9 },
-        expect: (r) => r.events?.every((e) => e.domains.includes('technology') && e.impactScore >= 0.9)
-            ? null
-            : 'domain/impact filter failed',
-    },
-    {
-        tool: 'causal_chain',
-        args: { event: 'printing', direction: 'effects', depth: 2 },
-        expect: (r) => {
-            if (r.error)
-                return `unexpected error: ${r.error}`;
-            if (r.root.id !== 'printing')
-                return `wrong root: ${r.root.id}`;
-            const titles = r.effects.map((e) => e.id);
-            // printing → rena, printing → indus
-            if (!titles.includes('rena'))
-                return `missing rena in effects: ${titles.join(',')}`;
-            return null;
-        },
-    },
-    {
-        tool: 'causal_chain',
-        args: { event: 'transformer', direction: 'causes', depth: 3 },
-        expect: (r) => {
-            if (r.error)
-                return `unexpected error: ${r.error}`;
-            if (r.root.id !== 'transformer')
-                return `wrong root: ${r.root.id}`;
-            const ids = r.causes.map((c) => c.id);
-            // transformer ← turing_m, dna_disc, iphone (depth 1)
-            if (!ids.includes('turing_m'))
-                return `missing turing_m: ${ids.join(',')}`;
-            return null;
-        },
-    },
-    {
-        tool: 'causal_chain',
-        args: { event: 'industrial', direction: 'both', depth: 2 },
-        expect: (r) => {
-            if (r.error)
-                return `unexpected error: ${r.error}`;
-            if (r.root.id !== 'indus')
-                return `title fuzzy match should resolve "industrial" → indus, got: ${r.root.id}`;
-            return null;
-        },
-    },
-    {
-        tool: 'causal_chain',
-        args: { event: 'nonexistent_xyz' },
-        expect: (r) => (r.error ? null : 'expected error for nonexistent event'),
-    },
-    {
-        tool: 'historical_resonance',
-        args: { situation: 'rapid democratization of knowledge through new technology' },
-        expect: (r) => {
-            if (!r.matches || r.matches.length === 0)
-                return 'expected at least 1 match';
-            // Should match info-democratization pattern
-            const found = r.matches.find((m) => m.pattern.toLowerCase().includes('democratization'));
-            return found ? null : `expected democratization pattern, got: ${r.matches.map((m) => m.pattern).join(', ')}`;
-        },
-    },
-    {
-        tool: 'predict_scenarios',
-        args: {
-            conditions: ['AI capabilities accelerating', 'open-source models improving'],
-            horizon: 2040,
-            domains: ['technology'],
-        },
-        expect: (r) => {
-            if (!r.scenarios || r.scenarios.length === 0)
-                return 'expected at least 1 scenario';
-            if (!r.scenarios.every((s) => typeof s.probability === 'number'))
-                return 'scenarios missing probability';
-            return null;
-        },
-    },
-    {
-        // Regression: a plausible condition that lexically matches no forecast-event
-        // text must still fall back to the horizon/domain set, not return empty.
-        tool: 'predict_scenarios',
-        args: { conditions: ['AI capability accelerating'], domains: ['technology'] },
-        expect: (r) => r.scenarios?.length > 0
-            ? null
-            : 'expected non-empty scenarios via horizon/domain fallback when conditions do not lexically match',
-    },
-    {
-        tool: 'org_knowledge',
-        args: { query: 'database decisions', orgId: 'demo-org-no-data' },
-        expect: (r) => (r.available === false ? null : 'expected available=false for empty org'),
-    },
-    // ── AI history extension (events-ai-history.ts) ──────────────────────
-    {
-        tool: 'query_events',
-        args: { query: 'chatgpt', limit: 3 },
-        expect: (r) => r.events?.some((e) => e.id === 'chatgpt')
-            ? null
-            : `expected chatgpt in results, got: ${r.events?.map((e) => e.id).join(',')}`,
-    },
-    {
-        tool: 'causal_chain',
-        args: { event: 'chatgpt', direction: 'causes', depth: 4 },
-        expect: (r) => {
-            if (r.error)
-                return `unexpected error: ${r.error}`;
-            const ids = r.causes.map((c) => c.id);
-            // chatgpt ← gpt3 ← gpt2 ← transformer ← alexnet
-            if (!ids.includes('gpt3'))
-                return `missing gpt3: ${ids.join(',')}`;
-            if (!ids.includes('transformer'))
-                return `missing transformer: ${ids.join(',')}`;
-            return null;
-        },
-    },
-];
-let passed = 0;
-let failed = 0;
-const failures = [];
-for (const t of tests) {
-    const tool = ALL_TOOLS.find((x) => x.name === t.tool);
-    if (!tool) {
-        failures.push(`Unknown tool ${t.tool}`);
-        failed++;
-        continue;
+import {
+  ALL_TOOLS,
+  CKGStore,
+  loadSeed
+} from "./chunk-KBU67SEH.js";
+
+// src/smoke.ts
+var store = new CKGStore(loadSeed());
+var stats = store.stats();
+console.log("CKG stats:", stats);
+var tests = [
+  {
+    tool: "query_events",
+    args: { query: "printing", limit: 5 },
+    expect: (r) => r.events?.length > 0 && r.events[0].id === "printing" ? null : `expected printing event, got ${JSON.stringify(r.events?.[0])}`
+  },
+  {
+    tool: "query_events",
+    args: { yearFrom: 1900, yearTo: 2e3, minImpact: 0.85 },
+    expect: (r) => r.events?.every((e) => e.yearNum >= 1900 && e.yearNum <= 2e3 && e.impactScore >= 0.85) ? null : "year/impact filter failed"
+  },
+  {
+    tool: "query_events",
+    args: { domains: ["technology"], minImpact: 0.9 },
+    expect: (r) => r.events?.every((e) => e.domains.includes("technology") && e.impactScore >= 0.9) ? null : "domain/impact filter failed"
+  },
+  {
+    tool: "causal_chain",
+    args: { event: "printing", direction: "effects", depth: 2 },
+    expect: (r) => {
+      if (r.error) return `unexpected error: ${r.error}`;
+      if (r.root.id !== "printing") return `wrong root: ${r.root.id}`;
+      const titles = r.effects.map((e) => e.id);
+      if (!titles.includes("rena")) return `missing rena in effects: ${titles.join(",")}`;
+      return null;
+    }
+  },
+  {
+    tool: "causal_chain",
+    args: { event: "transformer", direction: "causes", depth: 3 },
+    expect: (r) => {
+      if (r.error) return `unexpected error: ${r.error}`;
+      if (r.root.id !== "transformer") return `wrong root: ${r.root.id}`;
+      const ids = r.causes.map((c) => c.id);
+      if (!ids.includes("turing_m")) return `missing turing_m: ${ids.join(",")}`;
+      return null;
     }
-    const result = tool.handler(t.args, store);
-    const err = t.expect(result);
-    if (err) {
-        failed++;
-        failures.push(`[${t.tool}] ${JSON.stringify(t.args)}\n    → ${err}`);
+  },
+  {
+    tool: "causal_chain",
+    args: { event: "industrial", direction: "both", depth: 2 },
+    expect: (r) => {
+      if (r.error) return `unexpected error: ${r.error}`;
+      if (r.root.id !== "indus") return `title fuzzy match should resolve "industrial" \u2192 indus, got: ${r.root.id}`;
+      return null;
     }
-    else {
-        passed++;
+  },
+  {
+    tool: "causal_chain",
+    args: { event: "nonexistent_xyz" },
+    expect: (r) => r.error ? null : "expected error for nonexistent event"
+  },
+  {
+    tool: "historical_resonance",
+    args: { situation: "rapid democratization of knowledge through new technology" },
+    expect: (r) => {
+      if (!r.matches || r.matches.length === 0) return "expected at least 1 match";
+      const found = r.matches.find((m) => m.pattern.toLowerCase().includes("democratization"));
+      return found ? null : `expected democratization pattern, got: ${r.matches.map((m) => m.pattern).join(", ")}`;
     }
+  },
+  {
+    tool: "predict_scenarios",
+    args: {
+      conditions: ["AI capabilities accelerating", "open-source models improving"],
+      horizon: 2040,
+      domains: ["technology"]
+    },
+    expect: (r) => {
+      if (!r.scenarios || r.scenarios.length === 0) return "expected at least 1 scenario";
+      if (!r.scenarios.every((s) => typeof s.probability === "number")) return "scenarios missing probability";
+      return null;
+    }
+  },
+  {
+    // Regression: a plausible condition that lexically matches no forecast-event
+    // text must still fall back to the horizon/domain set, not return empty.
+    tool: "predict_scenarios",
+    args: { conditions: ["AI capability accelerating"], domains: ["technology"] },
+    expect: (r) => r.scenarios?.length > 0 ? null : "expected non-empty scenarios via horizon/domain fallback when conditions do not lexically match"
+  },
+  {
+    tool: "org_knowledge",
+    args: { query: "database decisions", orgId: "demo-org-no-data" },
+    expect: (r) => r.available === false ? null : "expected available=false for empty org"
+  },
+  // ── AI history extension (events-ai-history.ts) ──────────────────────
+  {
+    tool: "query_events",
+    args: { query: "chatgpt", limit: 3 },
+    expect: (r) => r.events?.some((e) => e.id === "chatgpt") ? null : `expected chatgpt in results, got: ${r.events?.map((e) => e.id).join(",")}`
+  },
+  {
+    tool: "causal_chain",
+    args: { event: "chatgpt", direction: "causes", depth: 4 },
+    expect: (r) => {
+      if (r.error) return `unexpected error: ${r.error}`;
+      const ids = r.causes.map((c) => c.id);
+      if (!ids.includes("gpt3")) return `missing gpt3: ${ids.join(",")}`;
+      if (!ids.includes("transformer")) return `missing transformer: ${ids.join(",")}`;
+      return null;
+    }
+  }
+];
+var passed = 0;
+var failed = 0;
+var failures = [];
+for (const t of tests) {
+  const tool = ALL_TOOLS.find((x) => x.name === t.tool);
+  if (!tool) {
+    failures.push(`Unknown tool ${t.tool}`);
+    failed++;
+    continue;
+  }
+  const result = tool.handler(t.args, store);
+  const err = t.expect(result);
+  if (err) {
+    failed++;
+    failures.push(`[${t.tool}] ${JSON.stringify(t.args)}
+    \u2192 ${err}`);
+  } else {
+    passed++;
+  }
 }
-console.log(`\n=== Smoke test ===`);
+console.log(`
+=== Smoke test ===`);
 console.log(`PASS: ${passed}/${tests.length}`);
 if (failed > 0) {
-    console.log(`FAIL: ${failed}`);
-    failures.forEach((f) => console.log(`  ${f}`));
-    process.exit(1);
-}
-else {
-    console.log('All tests passed.');
+  console.log(`FAIL: ${failed}`);
+  failures.forEach((f) => console.log(`  ${f}`));
+  process.exit(1);
+} else {
+  console.log("All tests passed.");
 }
-// Print one full sample so we can eyeball the LLM-facing format
-console.log('\n=== Sample causal_chain output ===');
-const sample = ALL_TOOLS.find((t) => t.name === 'causal_chain').handler({ event: 'transformer', direction: 'causes', depth: 2 }, store);
+console.log("\n=== Sample causal_chain output ===");
+var sample = ALL_TOOLS.find((t) => t.name === "causal_chain").handler(
+  { event: "transformer", direction: "causes", depth: 2 },
+  store
+);
 console.log(JSON.stringify(sample, null, 2));
-//# sourceMappingURL=smoke.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@causari/mcp-server",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
   "type": "module",
   "description": "Causari MCP Server — Causal Knowledge Graph for AI agents",
@@ -19,8 +19,9 @@
     }
   },
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
+    "build": "pnpm --filter @causari/ckg build && tsup",
+    "prepublishOnly": "pnpm build",
+    "dev": "tsup --watch",
     "start": "node dist/cli.js",
     "test": "tsx src/validate.test.ts && tsx src/worker.test.ts && pnpm build && node dist/smoke.js",
     "test:unit": "tsx src/validate.test.ts && tsx src/worker.test.ts",
@@ -29,10 +30,11 @@
     "deploy:dry": "wrangler deploy --dry-run"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.1",
-    "@causari/ckg": "workspace:*"
+    "@modelcontextprotocol/sdk": "^1.12.1"
   },
   "devDependencies": {
+    "@causari/ckg": "workspace:*",
+    "tsup": "^8.3.0",
     "wrangler": "^3.99.0",
     "typescript": "^5.7.0",
     "tsx": "^4.19.0",