npm - whygraph - Versions diffs - 0.1.0 - Mend

whygraph 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (92) hide show

package/LICENSE +21 -0
package/README.md +205 -0
package/dist/cli/commands/config.d.ts +14 -0
package/dist/cli/commands/config.js +123 -0
package/dist/cli/commands/down.d.ts +9 -0
package/dist/cli/commands/down.js +46 -0
package/dist/cli/commands/init.d.ts +17 -0
package/dist/cli/commands/init.js +144 -0
package/dist/cli/commands/issues.d.ts +10 -0
package/dist/cli/commands/issues.js +376 -0
package/dist/cli/commands/mcp.d.ts +2 -0
package/dist/cli/commands/mcp.js +9 -0
package/dist/cli/commands/restart.d.ts +11 -0
package/dist/cli/commands/restart.js +43 -0
package/dist/cli/commands/serve.d.ts +14 -0
package/dist/cli/commands/serve.js +132 -0
package/dist/cli/commands/server-utils.d.ts +6 -0
package/dist/cli/commands/server-utils.js +94 -0
package/dist/cli/commands/status.d.ts +11 -0
package/dist/cli/commands/status.js +97 -0
package/dist/cli/commands/up.d.ts +13 -0
package/dist/cli/commands/up.js +62 -0
package/dist/cli/commands/validate.d.ts +14 -0
package/dist/cli/commands/validate.js +88 -0
package/dist/cli/commands/viz.d.ts +7 -0
package/dist/cli/commands/viz.js +97 -0
package/dist/cli/index.d.ts +2 -0
package/dist/cli/index.js +33 -0
package/dist/entity/id.d.ts +8 -0
package/dist/entity/id.js +48 -0
package/dist/entity/issues.d.ts +12 -0
package/dist/entity/issues.js +68 -0
package/dist/entity/parser.d.ts +6 -0
package/dist/entity/parser.js +166 -0
package/dist/entity/types.d.ts +54 -0
package/dist/entity/types.js +21 -0
package/dist/entity/validate.d.ts +12 -0
package/dist/entity/validate.js +136 -0
package/dist/entity/writer.d.ts +16 -0
package/dist/entity/writer.js +142 -0
package/dist/frontend/assets/index-ByZzPwVe.css +1 -0
package/dist/frontend/assets/index-F9dxfzD_.js +170 -0
package/dist/frontend/index.html +14 -0
package/dist/graph/cascade.d.ts +10 -0
package/dist/graph/cascade.js +49 -0
package/dist/graph/decisions.d.ts +11 -0
package/dist/graph/decisions.js +27 -0
package/dist/graph/gaps.d.ts +10 -0
package/dist/graph/gaps.js +58 -0
package/dist/graph/nodes.d.ts +20 -0
package/dist/graph/nodes.js +33 -0
package/dist/graph/projection.d.ts +6 -0
package/dist/graph/projection.js +44 -0
package/dist/graph/query.d.ts +15 -0
package/dist/graph/query.js +82 -0
package/dist/graph/search.d.ts +2 -0
package/dist/graph/search.js +23 -0
package/dist/graph/supersede.d.ts +7 -0
package/dist/graph/supersede.js +48 -0
package/dist/graph/temporal.d.ts +13 -0
package/dist/graph/temporal.js +28 -0
package/dist/mcp/index.d.ts +2 -0
package/dist/mcp/index.js +10 -0
package/dist/mcp/server.d.ts +3 -0
package/dist/mcp/server.js +340 -0
package/dist/onboarding/interview.d.ts +22 -0
package/dist/onboarding/interview.js +92 -0
package/dist/onboarding/scan.d.ts +17 -0
package/dist/onboarding/scan.js +106 -0
package/dist/platform/rules.d.ts +8 -0
package/dist/platform/rules.js +229 -0
package/dist/server/core.d.ts +26 -0
package/dist/server/core.js +111 -0
package/dist/server/derived.d.ts +8 -0
package/dist/server/derived.js +13 -0
package/dist/server/etag.d.ts +9 -0
package/dist/server/etag.js +25 -0
package/dist/server/http.d.ts +13 -0
package/dist/server/http.js +131 -0
package/dist/server/pubsub.d.ts +12 -0
package/dist/server/pubsub.js +19 -0
package/dist/server/schema.d.ts +2 -0
package/dist/server/schema.js +362 -0
package/dist/server/stale-refs.d.ts +7 -0
package/dist/server/stale-refs.js +23 -0
package/dist/server/watcher.d.ts +21 -0
package/dist/server/watcher.js +98 -0
package/dist/server/worktree-watcher.d.ts +20 -0
package/dist/server/worktree-watcher.js +79 -0
package/dist/server/worktree.d.ts +22 -0
package/dist/server/worktree.js +84 -0
package/package.json +73 -0

package/dist/frontend/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en" data-theme="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="dark light" />
+    <title>whygraph</title>
+    <script type="module" crossorigin src="/assets/index-F9dxfzD_.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-ByZzPwVe.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/graph/cascade.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import type { Entity } from "../entity/types.js";
+export interface CascadeResult {
+    removedIds: string[];
+    orphanedDecisionIds: string[];
+    partialDecisionPatches: Array<{
+        id: string;
+        remainingAffects: string[];
+    }>;
+}
+export declare function cascadeRemoval(entities: Map<string, Entity>, nodeId: string, timestamp: string): CascadeResult;

package/dist/graph/cascade.js ADDED Viewed

@@ -0,0 +1,49 @@
+import graphology from "graphology";
+import { buildGraph } from "./projection.js";
+import { isDecisionNode } from "../entity/types.js";
+const MultiDirectedGraph = graphology.MultiDirectedGraph;
+export function cascadeRemoval(entities, nodeId, timestamp) {
+    const entityArray = Array.from(entities.values());
+    const graph = buildGraph(entityArray);
+    // Collect all descendants via COMPOSES edges (recursive)
+    const removalSet = new Set();
+    const queue = [nodeId];
+    while (queue.length > 0) {
+        const current = queue.pop();
+        /* v8 ignore next 1 */
+        if (removalSet.has(current))
+            continue;
+        if (!graph.hasNode(current))
+            continue;
+        removalSet.add(current);
+        // Find COMPOSES children: edges where current is source with label COMPOSES
+        graph.forEachOutEdge(current, (_edge, attrs, _source, target) => {
+            if (attrs.label === "COMPOSES" && !removalSet.has(target)) {
+                queue.push(target);
+            }
+        });
+    }
+    const removedIds = Array.from(removalSet);
+    const orphanedDecisionIds = [];
+    const partialDecisionPatches = [];
+    // Check all decisions
+    for (const entity of entityArray) {
+        if (!isDecisionNode(entity))
+            continue;
+        if (entity.removed_at !== undefined)
+            continue;
+        if (removalSet.has(entity.id))
+            continue;
+        const affectsInRemoval = entity.affects.filter((id) => removalSet.has(id));
+        if (affectsInRemoval.length === 0)
+            continue;
+        const remaining = entity.affects.filter((id) => !removalSet.has(id));
+        if (remaining.length === 0) {
+            orphanedDecisionIds.push(entity.id);
+        }
+        else {
+            partialDecisionPatches.push({ id: entity.id, remainingAffects: remaining });
+        }
+    }
+    return { removedIds, orphanedDecisionIds, partialDecisionPatches };
+}

package/dist/graph/decisions.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import graphology from "graphology";
+import type { DecisionNode, DecisionStatus, DecisionTag } from "../entity/types.js";
+type MultiDirectedGraph = graphology.MultiDirectedGraph;
+export interface DecisionFilters {
+    status?: DecisionStatus;
+    tags?: DecisionTag[];
+    dateFrom?: string;
+    dateTo?: string;
+}
+export declare function getDecisions(graph: MultiDirectedGraph, filters?: DecisionFilters): DecisionNode[];
+export {};

package/dist/graph/decisions.js ADDED Viewed

@@ -0,0 +1,27 @@
+export function getDecisions(graph, filters) {
+    const results = [];
+    graph.forEachNode((nodeId, attributes) => {
+        if (attributes.label !== "Decision")
+            return;
+        // Exclude removed decisions
+        if (attributes.removed_at !== undefined)
+            return;
+        // Status filter (AND)
+        if (filters?.status !== undefined && attributes.status !== filters.status)
+            return;
+        // Tags filter (OR within tags)
+        if (filters?.tags !== undefined && filters.tags.length > 0) {
+            const nodeTags = attributes.tags;
+            const hasMatch = filters.tags.some((tag) => nodeTags.includes(tag));
+            if (!hasMatch)
+                return;
+        }
+        // Date range filters (AND)
+        if (filters?.dateFrom !== undefined && attributes.date < filters.dateFrom)
+            return;
+        if (filters?.dateTo !== undefined && attributes.date > filters.dateTo)
+            return;
+        results.push({ id: nodeId, ...attributes });
+    });
+    return results;
+}

package/dist/graph/gaps.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import graphology from "graphology";
+import type { StructuralNode } from "../entity/types.js";
+type MultiDirectedGraph = graphology.MultiDirectedGraph;
+/**
+ * Find Feature/Component nodes with no inbound AFFECTS edges from any Decision.
+ * Order: Features first, then Components by COMPOSES depth (shallow first).
+ * Excludes removed nodes and App nodes.
+ */
+export declare function getGaps(graph: MultiDirectedGraph, limit?: number): StructuralNode[];
+export {};

package/dist/graph/gaps.js ADDED Viewed

@@ -0,0 +1,58 @@
+/**
+ * Find Feature/Component nodes with no inbound AFFECTS edges from any Decision.
+ * Order: Features first, then Components by COMPOSES depth (shallow first).
+ * Excludes removed nodes and App nodes.
+ */
+export function getGaps(graph, limit) {
+    const gaps = [];
+    graph.forEachNode((nodeId, attributes) => {
+        // Skip removed nodes
+        if (attributes.removed_at)
+            return;
+        // Only Feature and Component nodes
+        const label = attributes.label;
+        if (label !== "Feature" && label !== "Component")
+            return;
+        // Check for inbound AFFECTS edges
+        const hasAffects = graph.someInEdge(nodeId, (_edge, edgeAttrs) => {
+            return edgeAttrs.label === "AFFECTS";
+        });
+        if (!hasAffects) {
+            gaps.push({ id: nodeId, ...attributes });
+        }
+    });
+    // Sort: Features first, then Components by COMPOSES depth (shallow first)
+    gaps.sort((a, b) => {
+        if (a.label !== b.label) {
+            return a.label === "Feature" ? -1 : 1;
+        }
+        if (a.label === "Component" && b.label === "Component") {
+            const depthA = getComposesDepth(graph, a.id);
+            const depthB = getComposesDepth(graph, b.id);
+            return depthA - depthB;
+        }
+        return 0;
+    });
+    if (limit !== undefined) {
+        return gaps.slice(0, limit);
+    }
+    return gaps;
+}
+/** Count how many COMPOSES edges exist from root to this node. */
+function getComposesDepth(graph, nodeId) {
+    let depth = 0;
+    let current = nodeId;
+    while (true) {
+        let parentFound = null;
+        graph.forEachInEdge(current, (_edge, edgeAttrs, source) => {
+            if (edgeAttrs.label === "COMPOSES") {
+                parentFound = source;
+            }
+        });
+        if (parentFound === null)
+            break;
+        depth++;
+        current = parentFound;
+    }
+    return depth;
+}

package/dist/graph/nodes.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import graphology from "graphology";
+import type { NodeLabel } from "../entity/types.js";
+type MultiDirectedGraph = graphology.MultiDirectedGraph;
+export interface NodeFilters {
+    label?: NodeLabel;
+    parent?: string;
+    search?: string;
+}
+export interface NodeSummary {
+    id: string;
+    label: NodeLabel;
+    name: string;
+    parent?: string;
+}
+/**
+ * List nodes with optional filtering. Returns lightweight summaries.
+ * Excludes removed nodes.
+ */
+export declare function listNodes(graph: MultiDirectedGraph, filters?: NodeFilters): NodeSummary[];
+export {};

package/dist/graph/nodes.js ADDED Viewed

@@ -0,0 +1,33 @@
+/**
+ * List nodes with optional filtering. Returns lightweight summaries.
+ * Excludes removed nodes.
+ */
+export function listNodes(graph, filters) {
+    const results = [];
+    graph.forEachNode((nodeId, attributes) => {
+        // Exclude removed nodes
+        if (attributes.removed_at)
+            return;
+        const label = attributes.label;
+        const name = (attributes.name ?? attributes.title);
+        const parent = attributes.parent;
+        // Filter by label
+        if (filters?.label && label !== filters.label)
+            return;
+        // Filter by parent
+        if (filters?.parent && parent !== filters.parent)
+            return;
+        // Filter by search (case-insensitive substring on name/title)
+        if (filters?.search) {
+            const searchLower = filters.search.toLowerCase();
+            if (!name.toLowerCase().includes(searchLower))
+                return;
+        }
+        const summary = { id: nodeId, label, name };
+        if (parent !== undefined) {
+            summary.parent = parent;
+        }
+        results.push(summary);
+    });
+    return results;
+}

package/dist/graph/projection.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import graphology from "graphology";
+import type { Entity } from "../entity/types.js";
+type MultiDirectedGraph = graphology.MultiDirectedGraph;
+declare const MultiDirectedGraph: typeof graphology.MultiDirectedGraph;
+export declare function buildGraph(entities: Entity[]): MultiDirectedGraph;
+export {};

package/dist/graph/projection.js ADDED Viewed

@@ -0,0 +1,44 @@
+import graphology from "graphology";
+import { isStructuralNode, isDecisionNode } from "../entity/types.js";
+const MultiDirectedGraph = graphology.MultiDirectedGraph;
+export function buildGraph(entities) {
+    const graph = new MultiDirectedGraph();
+    // Phase 1: add all nodes
+    for (const entity of entities) {
+        const { id, ...attributes } = entity;
+        graph.addNode(id, attributes);
+    }
+    // Phase 2: derive edges
+    for (const entity of entities) {
+        // COMPOSES: parent → child
+        if (isStructuralNode(entity) && entity.parent !== undefined) {
+            if (graph.hasNode(entity.parent)) {
+                graph.addEdgeWithKey(`composes-${entity.parent}-${entity.id}`, entity.parent, entity.id, { label: "COMPOSES" });
+            }
+            else {
+                console.warn(`Skipping COMPOSES edge: parent "${entity.parent}" not found for node "${entity.id}"`);
+            }
+        }
+        // AFFECTS: decision → affected node
+        if (isDecisionNode(entity)) {
+            for (const targetId of entity.affects) {
+                if (graph.hasNode(targetId)) {
+                    graph.addEdgeWithKey(`affects-${entity.id}-${targetId}`, entity.id, targetId, { label: "AFFECTS" });
+                }
+                else {
+                    console.warn(`Skipping AFFECTS edge: target "${targetId}" not found for decision "${entity.id}"`);
+                }
+            }
+            // SUPERSEDES: new → old
+            if (entity.supersedes !== undefined) {
+                if (graph.hasNode(entity.supersedes)) {
+                    graph.addEdgeWithKey(`supersedes-${entity.id}-${entity.supersedes}`, entity.id, entity.supersedes, { label: "SUPERSEDES" });
+                }
+                else {
+                    console.warn(`Skipping SUPERSEDES edge: target "${entity.supersedes}" not found for decision "${entity.id}"`);
+                }
+            }
+        }
+    }
+    return graph;
+}

package/dist/graph/query.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import graphology from "graphology";
+import type { DecisionNode } from "../entity/types.js";
+type MultiDirectedGraph = graphology.MultiDirectedGraph;
+export interface ContextNodeResult {
+    id: string;
+    label: string;
+    name: string;
+    parentChain: string[];
+}
+export interface ContextResult {
+    nodes: ContextNodeResult[];
+    decisions: DecisionNode[];
+}
+export declare function getContext(graph: MultiDirectedGraph, file: string, symbol?: string): ContextResult;
+export {};

package/dist/graph/query.js ADDED Viewed

@@ -0,0 +1,82 @@
+function refMatches(refs, file, symbol) {
+    for (const ref of refs) {
+        if (ref.file !== file)
+            continue;
+        // File-level ref (no symbol) always matches
+        if (ref.symbol === undefined)
+            return true;
+        // If no symbol filter requested, any file match counts
+        if (symbol === undefined)
+            return true;
+        // Symbol must match
+        if (ref.symbol === symbol)
+            return true;
+    }
+    return false;
+}
+function getParentChain(graph, nodeId) {
+    const chain = [];
+    let current = nodeId;
+    while (true) {
+        // Find incoming COMPOSES edges (parent -> current)
+        const inEdges = graph.inEdges(current);
+        let foundParent = false;
+        for (const edgeKey of inEdges) {
+            if (graph.getEdgeAttribute(edgeKey, "label") === "COMPOSES") {
+                const parent = graph.source(edgeKey);
+                chain.push(parent);
+                current = parent;
+                foundParent = true;
+                break;
+            }
+        }
+        if (!foundParent)
+            break;
+    }
+    return chain;
+}
+function collectDecisions(graph, nodeIds) {
+    const decisions = new Map();
+    for (const nodeId of nodeIds) {
+        // Find incoming AFFECTS edges (decision -> node)
+        const inEdges = graph.inEdges(nodeId);
+        for (const edgeKey of inEdges) {
+            if (graph.getEdgeAttribute(edgeKey, "label") === "AFFECTS") {
+                const decisionId = graph.source(edgeKey);
+                /* v8 ignore next 1 */
+                if (!decisions.has(decisionId)) {
+                    decisions.set(decisionId, {
+                        id: decisionId,
+                        ...graph.getNodeAttributes(decisionId),
+                    });
+                }
+            }
+        }
+    }
+    return Array.from(decisions.values());
+}
+export function getContext(graph, file, symbol) {
+    const matchedNodes = [];
+    const allRelevantNodeIds = new Set();
+    graph.forEachNode((nodeId, attributes) => {
+        const refs = attributes.refs;
+        if (!refs || refs.length === 0)
+            return;
+        if (!refMatches(refs, file, symbol))
+            return;
+        const parentChain = getParentChain(graph, nodeId);
+        matchedNodes.push({
+            id: nodeId,
+            label: attributes.label,
+            name: attributes.name,
+            parentChain,
+        });
+        // Collect this node and all ancestors for decision lookup
+        allRelevantNodeIds.add(nodeId);
+        for (const ancestorId of parentChain) {
+            allRelevantNodeIds.add(ancestorId);
+        }
+    });
+    const decisions = collectDecisions(graph, allRelevantNodeIds);
+    return { nodes: matchedNodes, decisions };
+}

package/dist/graph/search.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { Entity, DecisionNode } from "../entity/types.js";
2	+ export declare function searchDecisions(entities: Map<string, Entity>, query: string): DecisionNode[];

package/dist/graph/search.js ADDED Viewed

@@ -0,0 +1,23 @@
+import { isDecisionNode } from "../entity/types.js";
+export function searchDecisions(entities, query) {
+    const lowerQuery = query.toLowerCase();
+    const results = [];
+    for (const entity of entities.values()) {
+        if (!isDecisionNode(entity))
+            continue;
+        if (entity.removed_at !== undefined)
+            continue;
+        const searchable = [
+            entity.title,
+            entity.context,
+            entity.decision,
+            entity.tradeoffs,
+            entity.alternatives,
+        ];
+        const matches = searchable.some((field) => field.toLowerCase().includes(lowerQuery));
+        if (matches) {
+            results.push(entity);
+        }
+    }
+    return results;
+}

package/dist/graph/supersede.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { Entity } from "../entity/types.js";
+export interface SupersedeCandidate {
+    newDecisionId: string;
+    existingDecisionId: string;
+    sharedNodeIds: string[];
+}
+export declare function detectSupersedeCandidates(entities: Map<string, Entity>): SupersedeCandidate[];

package/dist/graph/supersede.js ADDED Viewed

@@ -0,0 +1,48 @@
+import { isDecisionNode } from "../entity/types.js";
+export function detectSupersedeCandidates(entities) {
+    // Collect active, non-removed decisions
+    const activeDecisions = [];
+    for (const entity of entities.values()) {
+        if (!isDecisionNode(entity))
+            continue;
+        if (entity.removed_at !== undefined)
+            continue;
+        if (entity.status === "superseded")
+            continue;
+        activeDecisions.push(entity);
+    }
+    // Build a set of existing supersedes relationships for exclusion
+    const supersededPairs = new Set();
+    for (const entity of entities.values()) {
+        if (!isDecisionNode(entity))
+            continue;
+        if (entity.supersedes !== undefined) {
+            // Normalize as "newer->older"
+            supersededPairs.add(`${entity.id}->${entity.supersedes}`);
+        }
+    }
+    const candidates = [];
+    for (let i = 0; i < activeDecisions.length; i++) {
+        for (let j = i + 1; j < activeDecisions.length; j++) {
+            const a = activeDecisions[i];
+            const b = activeDecisions[j];
+            // Check if already in a supersedes relationship (either direction)
+            if (supersededPairs.has(`${a.id}->${b.id}`) ||
+                supersededPairs.has(`${b.id}->${a.id}`)) {
+                continue;
+            }
+            const aSet = new Set(a.affects);
+            const shared = b.affects.filter((id) => aSet.has(id));
+            if (shared.length > 0) {
+                // Newer decision (later date or later created_at) is "new", other is "existing"
+                const aIsNewer = a.created_at > b.created_at;
+                candidates.push({
+                    newDecisionId: aIsNewer ? a.id : b.id,
+                    existingDecisionId: aIsNewer ? b.id : a.id,
+                    sharedNodeIds: shared,
+                });
+            }
+        }
+    }
+    return candidates;
+}

package/dist/graph/temporal.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import graphology from "graphology";
+import type { Entity } from "../entity/types.js";
+type MultiDirectedGraph = graphology.MultiDirectedGraph;
+/**
+ * Build a graph projection at a specific point in time.
+ * Includes entities where created_at <= timestamp AND (removed_at is null OR removed_at > timestamp).
+ */
+export declare function buildGraphAt(entities: Entity[], timestamp: string): MultiDirectedGraph;
+/**
+ * Collect all unique timestamps (created_at and removed_at) from entities, sorted chronologically.
+ */
+export declare function getTimestamps(entities: Entity[]): string[];
+export {};

package/dist/graph/temporal.js ADDED Viewed

@@ -0,0 +1,28 @@
+import { buildGraph } from "./projection.js";
+/**
+ * Build a graph projection at a specific point in time.
+ * Includes entities where created_at <= timestamp AND (removed_at is null OR removed_at > timestamp).
+ */
+export function buildGraphAt(entities, timestamp) {
+    const filtered = entities.filter((entity) => {
+        if (entity.created_at > timestamp)
+            return false;
+        if (entity.removed_at !== undefined && entity.removed_at <= timestamp)
+            return false;
+        return true;
+    });
+    return buildGraph(filtered);
+}
+/**
+ * Collect all unique timestamps (created_at and removed_at) from entities, sorted chronologically.
+ */
+export function getTimestamps(entities) {
+    const set = new Set();
+    for (const entity of entities) {
+        set.add(entity.created_at);
+        if (entity.removed_at !== undefined) {
+            set.add(entity.removed_at);
+        }
+    }
+    return [...set].sort();
+}

package/dist/mcp/index.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ #!/usr/bin/env node
2	+ export {};

package/dist/mcp/index.js ADDED Viewed

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * MCP server entrypoint. When run directly, starts the stdio-based MCP server.
+ * For programmatic use, import from ./server.js instead.
+ */
+import { startMcpServer } from "./server.js";
+startMcpServer().catch((err) => {
+    console.error("Failed to start MCP server:", err);
+    process.exit(1);
+});

package/dist/mcp/server.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createMcpServer(): McpServer;
+export declare function startMcpServer(): Promise<void>;