@gmickel/gno 1.4.2 → 1.5.0

package/assets/skill/SKILL.md

@@ -133,13 +133,21 @@ gno search "error handling" --json | jq -r '.results[].uri' | xargs gno multi-ge
 
 ## MCP Retrieval Strategy
 
-When using GNO through MCP, prefer `gno_query` first for normal questions. It returns snippets plus `uri`, `docid`, and often `line`; follow with `gno_get` using `fromLine`/`lineCount` for a bounded read, or `gno_multi_get` to batch top result refs.
+When using GNO through MCP, prefer this retrieval order:
+
+1. Check `gno_status` first when freshness, missing vectors, or stale results are plausible.
+2. Use `gno_query` first for normal content questions. It returns snippets plus `uri`, `docid`, and often `line`; it also adds bounded one-hop graph neighbors from top seeds when graph data exists.
+3. Use graph/link expansion for relationship context: `gno_graph_neighbors` for nearby documents, `gno_graph_path` for "how are X and Y connected?", `gno_links`/`gno_backlinks` for one-document link expansion, and `gno_similar` for semantic neighbors. Prefer `explicit` graph edges over `inferred`, `ambiguous`, or `similarity` edges when confidence matters.
+4. Use `gno_get` with `fromLine`/`lineCount` for targeted reads, or `gno_multi_get` to batch top refs.
 
 Use narrower tools when the request tells you to:
 
 - `gno_search`: exact phrase, filename, identifier, stack trace, error text
 - `gno_vsearch`: conceptual similarity when exact wording differs
 - `gno_status`: stale results, missing embeddings, vector unavailable
+- `gno_graph`: graph report/stats, hubs, isolates, unresolved links, edge confidence/audit, communities, unfamiliar corpus overview
+- `gno_graph_neighbors`: relationship/corpus-navigation questions around a known document
+- `gno_graph_path`: "how are X and Y connected?" questions
 
 For ambiguous terms, pass `intent` instead of bloating the query text. For typed retrieval, use `queryModes`: `term` for lexical anchors, `intent` for disambiguation, one `hyde` for a hypothetical answer/document.
 
@@ -164,6 +172,8 @@ gno similar gno://notes/auth.md --threshold 0.85
 # Knowledge graph
 gno graph --json
 gno graph -c notes --similar   # Include similarity edges
+gno graph --neighbors gno://notes/auth.md
+gno graph --from gno://notes/a.md --to gno://notes/b.md
 ```
 
 ## Global Flags

package/assets/skill/cli-reference.md

@@ -154,7 +154,7 @@ gno query <query> [options]
 
 | Flag         | Time  | Description                    |
 | ------------ | ----- | ------------------------------ |
-| `--fast`     | ~0.7s | Skip expansion and reranking   |
+| `--fast`     | ~0.7s | Skip expansion, graph, rerank  |
 | (default)    | ~2-3s | Skip expansion, with reranking |
 | `--thorough` | ~5-8s | Full pipeline with expansion   |
 
@@ -164,6 +164,7 @@ Additional options:
 | ------------- | --------------------------------- |
 | `--no-expand` | Disable query expansion           |
 | `--no-rerank` | Disable reranking                 |
+| `--no-graph`  | Disable graph-neighbor candidates |
 | `--explain`   | Print retrieval details to stderr |
 
 ### gno ask
@@ -304,6 +305,8 @@ Generate knowledge graph of document connections.
 
 ```bash
 gno graph [options]
+gno graph --neighbors <ref> [--direction both|out|in]
+gno graph --from <ref> --to <ref> [--max-depth 6]
 ```
 
 | Option             | Default | Description                    |
@@ -315,9 +318,14 @@ gno graph [options]
 | `--threshold`      | 0.7     | Similarity threshold (0-1)     |
 | `--linked-only`    | true    | Exclude isolated nodes         |
 | `--similar-top-k`  | 5       | Similar docs per node (max 20) |
+| `--neighbors`      | -       | Show graph neighbors for ref   |
+| `--direction`      | both    | Neighbor direction             |
+| `--from`, `--to`   | -       | Find shortest graph path       |
+| `--max-depth`      | 6       | Max path hops                  |
 | `--json`           | -       | JSON output                    |
 
 **Edge types**: `wiki` (wiki links), `markdown` (md links), `similar` (vector similarity).
+JSON edges include `confidence` (`explicit`, `inferred`, `ambiguous`, `similarity`) and `audit` metadata so agents can prefer exact links over fallback or collision-prone matches.
 
 **Web UI**: Access interactive graph at `http://localhost:3000/graph` via `gno serve`.
 

package/assets/skill/mcp-reference.md

@@ -53,6 +53,22 @@ gno mcp install -t claude-code -s project # Project scope
 gno mcp status
 ```
 
+## Retrieval Order
+
+For normal questions, start with `gno_query`, then read targeted snippets with
+`gno_get` or batch refs with `gno_multi_get`. `gno_query` already does bounded
+one-hop graph expansion from top seeds; pass `noGraph: true` only when comparing
+pure BM25/vector retrieval. Check `gno_status` first when freshness or
+embeddings may be stale.
+
+Use graph tools for relationship context: `gno_graph` for corpus report/stats,
+community summaries,
+`gno_graph_neighbors` for nearby incoming/outgoing graph context, and
+`gno_graph_path` for "how are X and Y connected?" questions. Use
+`gno_links`, `gno_backlinks`, and `gno_similar` for one-document expansion.
+Graph edges include confidence/audit metadata; prefer `explicit` edges when
+answers depend on link certainty.
+
 ## Uninstall
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/src/cli/commands/graph.ts

@@ -32,12 +32,55 @@ export interface GraphOptions {
   similarTopK?: number;
   /** Output format: json (default), dot, mermaid */
   format?: "json" | "dot" | "mermaid";
+  /** Show neighbors for a graph node/ref */
+  neighbors?: string;
+  /** Neighbor direction */
+  direction?: "both" | "out" | "in";
+  /** Path start graph node/ref */
+  from?: string;
+  /** Path target graph node/ref */
+  to?: string;
+  /** Max path hops */
+  maxDepth?: number;
 }
 
 export type GraphCommandResult =
   | { success: true; data: GraphResult }
+  | { success: true; data: GraphNeighborsCliResult }
+  | { success: true; data: GraphPathCliResult }
   | { success: false; error: string; isValidation?: boolean };
 
+type GraphNode = GraphResult["nodes"][number];
+type GraphLink = GraphResult["links"][number];
+
+interface GraphNeighborCliItem {
+  node: GraphNode;
+  direction: "out" | "in";
+  edge: GraphLink;
+}
+
+interface GraphNeighborsCliResult {
+  source: GraphNode;
+  neighbors: GraphNeighborCliItem[];
+  meta: GraphResult["meta"] & {
+    mode: "neighbors";
+    direction: "both" | "out" | "in";
+    totalNeighbors: number;
+  };
+}
+
+interface GraphPathCliResult {
+  from: GraphNode;
+  to: GraphNode;
+  path: { nodes: GraphNode[]; edges: GraphLink[] } | null;
+  meta: GraphResult["meta"] & {
+    mode: "path";
+    maxDepth: number;
+    found: boolean;
+    hops: number;
+  };
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Command: graph
 // ─────────────────────────────────────────────────────────────────────────────
@@ -74,12 +117,162 @@ export async function graph(
       return { success: false, error: result.error.message };
     }
 
+    if (options.neighbors) {
+      const source = resolveGraphNode(result.value, options.neighbors);
+      if (!source) {
+        return {
+          success: false,
+          error: `Graph node not found: ${options.neighbors}`,
+          isValidation: true,
+        };
+      }
+      const direction = options.direction ?? "both";
+      const neighbors = getGraphNeighbors(result.value, source, direction);
+      return {
+        success: true,
+        data: {
+          source,
+          neighbors,
+          meta: {
+            ...result.value.meta,
+            mode: "neighbors",
+            direction,
+            totalNeighbors: neighbors.length,
+          },
+        },
+      };
+    }
+
+    if (options.from || options.to) {
+      if (!(options.from && options.to)) {
+        return {
+          success: false,
+          error: "--from and --to must be used together",
+          isValidation: true,
+        };
+      }
+      const from = resolveGraphNode(result.value, options.from);
+      const to = resolveGraphNode(result.value, options.to);
+      if (!from || !to) {
+        return {
+          success: false,
+          error: `Graph node not found: ${from ? options.to : options.from}`,
+          isValidation: true,
+        };
+      }
+      const maxDepth = options.maxDepth ?? 6;
+      const path = findShortestPath(result.value, from, to, maxDepth);
+      return {
+        success: true,
+        data: {
+          from,
+          to,
+          path,
+          meta: {
+            ...result.value.meta,
+            mode: "path",
+            maxDepth,
+            found: path !== null,
+            hops: path ? path.edges.length : 0,
+          },
+        },
+      };
+    }
+
     return { success: true, data: result.value };
   } finally {
     await store.close();
   }
 }
 
+function resolveGraphNode(
+  graphResult: GraphResult,
+  ref: string
+): GraphNode | null {
+  const normalized = ref.trim().toLowerCase();
+  return (
+    graphResult.nodes.find((node) => {
+      const title = node.title?.toLowerCase();
+      return (
+        node.id.toLowerCase() === normalized ||
+        node.uri.toLowerCase() === normalized ||
+        node.relPath.toLowerCase() === normalized ||
+        `${node.collection}/${node.relPath}`.toLowerCase() === normalized ||
+        title === normalized
+      );
+    }) ?? null
+  );
+}
+
+function getGraphNeighbors(
+  graphResult: GraphResult,
+  source: GraphNode,
+  direction: "both" | "out" | "in"
+): GraphNeighborCliItem[] {
+  const nodesById = new Map(graphResult.nodes.map((node) => [node.id, node]));
+  const neighbors: GraphNeighborCliItem[] = [];
+  for (const edge of graphResult.links) {
+    if (direction !== "in" && edge.source === source.id) {
+      const node = nodesById.get(edge.target);
+      if (node) neighbors.push({ node, direction: "out", edge });
+    }
+    if (direction !== "out" && edge.target === source.id) {
+      const node = nodesById.get(edge.source);
+      if (node) neighbors.push({ node, direction: "in", edge });
+    }
+  }
+  return neighbors.sort((a, b) => a.node.uri.localeCompare(b.node.uri));
+}
+
+function findShortestPath(
+  graphResult: GraphResult,
+  from: GraphNode,
+  to: GraphNode,
+  maxDepth: number
+): { nodes: GraphNode[]; edges: GraphLink[] } | null {
+  const nodesById = new Map(graphResult.nodes.map((node) => [node.id, node]));
+  const adjacency = new Map<string, Array<{ next: string; edge: GraphLink }>>();
+  for (const edge of graphResult.links) {
+    const sourceEdges = adjacency.get(edge.source) ?? [];
+    sourceEdges.push({ next: edge.target, edge });
+    adjacency.set(edge.source, sourceEdges);
+
+    const targetEdges = adjacency.get(edge.target) ?? [];
+    targetEdges.push({ next: edge.source, edge });
+    adjacency.set(edge.target, targetEdges);
+  }
+
+  const queue: Array<{ id: string; edges: GraphLink[] }> = [
+    { id: from.id, edges: [] },
+  ];
+  const visited = new Set([from.id]);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) break;
+    if (current.id === to.id) {
+      const nodeIds = [from.id];
+      let cursor = from.id;
+      for (const edge of current.edges) {
+        cursor = edge.source === cursor ? edge.target : edge.source;
+        nodeIds.push(cursor);
+      }
+      return {
+        nodes: nodeIds
+          .map((id) => nodesById.get(id))
+          .filter((node): node is GraphNode => node !== undefined),
+        edges: current.edges,
+      };
+    }
+    if (current.edges.length >= maxDepth) continue;
+    for (const { next, edge } of adjacency.get(current.id) ?? []) {
+      if (visited.has(next)) continue;
+      visited.add(next);
+      queue.push({ id: next, edges: [...current.edges, edge] });
+    }
+  }
+  return null;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Formatters
 // ─────────────────────────────────────────────────────────────────────────────
@@ -119,10 +312,18 @@ export function formatDot(result: GraphResult): string {
   for (const link of result.links) {
     const style =
       link.type === "similar"
-        ? ' [style=dashed, color="#888888", dir=none]'
-        : "";
+        ? 'style=dashed, color="#888888", dir=none'
+        : link.confidence === "ambiguous"
+          ? 'style=dotted, color="#d97706"'
+          : link.confidence === "inferred"
+            ? 'style=dashed, color="#64748b"'
+            : "";
+    const attrs = [
+      style,
+      `label="${escapeDot(`${link.type}/${link.confidence}`)}"`,
+    ].filter(Boolean);
     lines.push(
-      `  "${escapeDot(link.source)}" -> "${escapeDot(link.target)}"${style};`
+      `  "${escapeDot(link.source)}" -> "${escapeDot(link.target)}" [${attrs.join(", ")}];`
     );
   }
 
@@ -154,7 +355,9 @@ export function formatMermaid(result: GraphResult): string {
     const sourceId = nodeIds.get(link.source) ?? link.source;
     const targetId = nodeIds.get(link.target) ?? link.target;
     const arrow = link.type === "similar" ? "---" : "-->";
-    lines.push(`  ${sourceId} ${arrow} ${targetId}`);
+    lines.push(
+      `  ${sourceId} ${arrow}|${escapeMermaid(`${link.type}/${link.confidence}`)}| ${targetId}`
+    );
   }
 
   return lines.join("\n");
@@ -178,6 +381,36 @@ export function formatGraph(
 
   const { data } = result;
 
+  if ("neighbors" in data) {
+    if (options.format === "json" || !options.format) {
+      return JSON.stringify(data, null, 2);
+    }
+    if (data.neighbors.length === 0) {
+      return `No graph neighbors found for ${data.source.uri} (direction=${data.meta.direction})`;
+    }
+    const lines = [
+      `Found ${data.neighbors.length} graph neighbors for ${data.source.uri}:`,
+      "",
+    ];
+    for (const item of data.neighbors) {
+      const title = item.node.title ? ` "${item.node.title}"` : "";
+      lines.push(
+        `  [${item.direction}] ${item.node.uri}${title} (${item.edge.type}, ${item.edge.confidence}, weight: ${item.edge.weight})`
+      );
+    }
+    return lines.join("\n");
+  }
+
+  if ("path" in data) {
+    if (options.format === "json" || !options.format) {
+      return JSON.stringify(data, null, 2);
+    }
+    if (!data.path) {
+      return `No graph path found from ${data.from.uri} to ${data.to.uri} within ${data.meta.maxDepth} hops`;
+    }
+    return `Graph path (${data.meta.hops} hops):\n${data.path.nodes.map((node) => node.uri).join(" -> ")}`;
+  }
+
   switch (options.format) {
     case "dot":
       return formatDot(data);

package/src/cli/program.ts

@@ -539,6 +539,7 @@ function wireSearchCommands(program: Command): void {
     )
     .option("--no-expand", "disable query expansion")
     .option("--no-rerank", "disable reranking")
+    .option("--no-graph", "disable graph neighbor expansion")
     .option(
       "--query-mode <mode:text>",
       "structured mode entry (repeatable): term:<text>, intent:<text>, or hyde:<text>",
@@ -655,6 +656,7 @@ function wireSearchCommands(program: Command): void {
         lineNumbers: Boolean(cmdOpts.lineNumbers),
         noExpand: depthPolicy.noExpand,
         noRerank: depthPolicy.noRerank,
+        noGraph: Boolean(cmdOpts.fast) || cmdOpts.graph === false,
         candidateLimit: depthPolicy.candidateLimit,
         queryModes,
         explain: Boolean(cmdOpts.explain),
@@ -2223,6 +2225,11 @@ function wireGraphCommand(program: Command): void {
     .option("--threshold <n>", "similarity threshold (default 0.7)")
     .option("--include-isolated", "include nodes with no links")
     .option("--similar-top-k <n>", "similar docs per node (default 5)")
+    .option("--neighbors <ref>", "show graph neighbors for document/node ref")
+    .option("--direction <dir>", "neighbor direction: both, out, in", "both")
+    .option("--from <ref>", "path start document/node ref")
+    .option("--to <ref>", "path target document/node ref")
+    .option("--max-depth <n>", "max path hops (default 6)")
     .option("--json", "JSON output (default)")
     .option("--dot", "Graphviz DOT output")
     .option("--mermaid", "Mermaid diagram output")
@@ -2259,6 +2266,25 @@ function wireGraphCommand(program: Command): void {
       const similarTopK = cmdOpts.similarTopK
         ? parsePositiveInt("similar-top-k", cmdOpts.similarTopK)
         : undefined;
+      const maxDepth = cmdOpts.maxDepth
+        ? parsePositiveInt("max-depth", cmdOpts.maxDepth)
+        : undefined;
+      if (
+        cmdOpts.direction !== "both" &&
+        cmdOpts.direction !== "out" &&
+        cmdOpts.direction !== "in"
+      ) {
+        throw new CliError(
+          "VALIDATION",
+          "--direction must be one of: both, out, in"
+        );
+      }
+      if (cmdOpts.neighbors && (cmdOpts.from || cmdOpts.to)) {
+        throw new CliError(
+          "VALIDATION",
+          "--neighbors cannot be combined with --from/--to"
+        );
+      }
 
       const { graph, formatGraph } = await import("./commands/graph.js");
       const result = await graph({
@@ -2271,6 +2297,11 @@ function wireGraphCommand(program: Command): void {
         includeIsolated: Boolean(cmdOpts.includeIsolated),
         similarTopK,
         format,
+        neighbors: cmdOpts.neighbors as string | undefined,
+        direction: cmdOpts.direction as "both" | "out" | "in",
+        from: cmdOpts.from as string | undefined,
+        to: cmdOpts.to as string | undefined,
+        maxDepth,
       });
 
       if (!result.success) {

package/src/core/graph-analysis.ts

@@ -0,0 +1,201 @@
+import type { GraphLink, GraphNode } from "../store/types";
+
+export interface GraphCommunity {
+  id: string;
+  label: string;
+  size: number;
+  edgeCount: number;
+  density: number;
+  topNodes: Array<
+    Pick<
+      GraphNode,
+      "id" | "uri" | "title" | "collection" | "relPath" | "degree"
+    >
+  >;
+}
+
+export interface GraphCommunityAnalysis {
+  total: number;
+  algorithm: "deterministic-label-propagation";
+  skipped: boolean;
+  assignments: Record<string, string>;
+  communities: GraphCommunity[];
+  warnings: string[];
+}
+
+const DEFAULT_COMMUNITY_NODE_CAP = 2000;
+const MAX_ITERATIONS = 8;
+
+const confidenceFactor = (confidence: GraphLink["confidence"]): number => {
+  switch (confidence) {
+    case "explicit":
+      return 1;
+    case "inferred":
+      return 0.75;
+    case "ambiguous":
+      return 0.5;
+    case "similarity":
+      return 0.35;
+  }
+};
+
+const edgeStrength = (edge: GraphLink): number =>
+  Math.max(0.01, edge.weight) * confidenceFactor(edge.confidence);
+
+export function analyzeGraphCommunities(
+  nodes: GraphNode[],
+  links: GraphLink[],
+  options: { nodeCap?: number } = {}
+): GraphCommunityAnalysis {
+  const nodeCap = options.nodeCap ?? DEFAULT_COMMUNITY_NODE_CAP;
+  if (nodes.length === 0) {
+    return {
+      total: 0,
+      algorithm: "deterministic-label-propagation",
+      skipped: false,
+      assignments: {},
+      communities: [],
+      warnings: [],
+    };
+  }
+
+  if (nodes.length > nodeCap) {
+    return {
+      total: 0,
+      algorithm: "deterministic-label-propagation",
+      skipped: true,
+      assignments: {},
+      communities: [],
+      warnings: [
+        `Community detection skipped: graph has ${nodes.length} nodes (cap ${nodeCap})`,
+      ],
+    };
+  }
+
+  const sortedNodes = [...nodes].sort((a, b) => a.id.localeCompare(b.id));
+  const nodeIds = new Set(sortedNodes.map((node) => node.id));
+  const adjacency = new Map<string, Map<string, number>>();
+  for (const node of sortedNodes) {
+    adjacency.set(node.id, new Map());
+  }
+
+  for (const edge of links) {
+    if (!(nodeIds.has(edge.source) && nodeIds.has(edge.target))) continue;
+    if (edge.source === edge.target) continue;
+    const strength = edgeStrength(edge);
+    const sourceNeighbors = adjacency.get(edge.source);
+    const targetNeighbors = adjacency.get(edge.target);
+    if (!(sourceNeighbors && targetNeighbors)) continue;
+    sourceNeighbors.set(
+      edge.target,
+      (sourceNeighbors.get(edge.target) ?? 0) + strength
+    );
+    targetNeighbors.set(
+      edge.source,
+      (targetNeighbors.get(edge.source) ?? 0) + strength
+    );
+  }
+
+  const labels = new Map(sortedNodes.map((node) => [node.id, node.id]));
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    let changed = false;
+    for (const node of sortedNodes) {
+      const neighbors = adjacency.get(node.id);
+      if (!neighbors || neighbors.size === 0) continue;
+
+      const scores = new Map<string, number>();
+      for (const [neighborId, strength] of neighbors) {
+        const label = labels.get(neighborId) ?? neighborId;
+        scores.set(label, (scores.get(label) ?? 0) + strength);
+      }
+
+      const currentLabel = labels.get(node.id) ?? node.id;
+      let bestLabel = currentLabel;
+      let bestScore = scores.get(currentLabel) ?? 0;
+      for (const [candidate, score] of [...scores.entries()].sort((a, b) =>
+        a[0].localeCompare(b[0])
+      )) {
+        if (
+          score > bestScore ||
+          (score === bestScore && candidate < bestLabel)
+        ) {
+          bestLabel = candidate;
+          bestScore = score;
+        }
+      }
+      if (bestLabel !== currentLabel) {
+        labels.set(node.id, bestLabel);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+
+  const groups = new Map<string, GraphNode[]>();
+  for (const node of sortedNodes) {
+    const label = labels.get(node.id) ?? node.id;
+    const group = groups.get(label) ?? [];
+    group.push(node);
+    groups.set(label, group);
+  }
+
+  const edgeCountByLabel = new Map<string, number>();
+  for (const edge of links) {
+    const sourceLabel = labels.get(edge.source);
+    const targetLabel = labels.get(edge.target);
+    if (!sourceLabel || sourceLabel !== targetLabel) continue;
+    edgeCountByLabel.set(
+      sourceLabel,
+      (edgeCountByLabel.get(sourceLabel) ?? 0) + 1
+    );
+  }
+
+  const orderedGroups = [...groups.entries()].sort((a, b) => {
+    const sizeDelta = b[1].length - a[1].length;
+    if (sizeDelta !== 0) return sizeDelta;
+    const aUri = a[1][0]?.uri ?? a[0];
+    const bUri = b[1][0]?.uri ?? b[0];
+    return aUri.localeCompare(bUri);
+  });
+
+  const labelToCommunityId = new Map<string, string>();
+  const communities = orderedGroups.map(([label, group], index) => {
+    const communityId = `c${index + 1}`;
+    labelToCommunityId.set(label, communityId);
+    const sortedGroup = [...group].sort(
+      (a, b) => b.degree - a.degree || a.uri.localeCompare(b.uri)
+    );
+    const edgeCount = edgeCountByLabel.get(label) ?? 0;
+    const maxUndirectedEdges = (group.length * (group.length - 1)) / 2;
+    return {
+      id: communityId,
+      label: sortedGroup[0]?.title ?? sortedGroup[0]?.relPath ?? communityId,
+      size: group.length,
+      edgeCount,
+      density: maxUndirectedEdges > 0 ? edgeCount / maxUndirectedEdges : 0,
+      topNodes: sortedGroup.slice(0, 5).map((node) => ({
+        id: node.id,
+        uri: node.uri,
+        title: node.title,
+        collection: node.collection,
+        relPath: node.relPath,
+        degree: node.degree,
+      })),
+    };
+  });
+
+  const assignments: Record<string, string> = {};
+  for (const node of sortedNodes) {
+    const label = labels.get(node.id) ?? node.id;
+    assignments[node.id] = labelToCommunityId.get(label) ?? "c0";
+  }
+
+  return {
+    total: communities.length,
+    algorithm: "deterministic-label-propagation",
+    skipped: false,
+    assignments,
+    communities: communities.slice(0, 10),
+    warnings: [],
+  };
+}