Per-language GitHub links from Schema 2.0 envelope inputs

buildGitHubLink now reads per-language source configs (repo URL,
commit ref, path prefix) extracted from the Schema 2.0 inputs array,
so Rust nodes link to dalek-cryptography/curve25519-dalek and Lean
nodes link to Beneficial-AI-Foundation/curve25519-dalek-lean-verify
without any manual URL parameters.

Made-with: Cursor

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: astefano

web/src/graph-loader.ts

@@ -1,5 +1,6 @@
 import {
-  D3Graph, D3Node, D3Link, SimplifiedNode, ProbeAtom,
+  D3Graph, D3Node, D3Link, SimplifiedNode, ProbeAtom, SourceConfig,
+  Schema2Envelope, Schema2Source,
   isSimplifiedFormat, isD3GraphFormat, isAtomDictFormat, isSchema2Envelope,
   VerificationStatus,
 } from './types';
@@ -183,9 +184,35 @@ export function convertAtomDictToD3Graph(atoms: Record<string, ProbeAtom>): D3Gr
  * Supports D3Graph format, simplified format, probe atom dict format,
  * and Schema 2.0 envelopes.
  */
+/**
+ * Extract per-language GitHub source configs from a Schema 2.0 envelope.
+ * Uses the commit hash as the git ref (always valid on GitHub).
+ * For Rust workspace crates the package name becomes the path prefix.
+ */
+function extractSourceConfigs(envelope: Schema2Envelope): SourceConfig[] {
+  const entries: Schema2Source[] = [];
+  if (envelope.inputs) {
+    for (const input of envelope.inputs) entries.push(input.source);
+  } else if (envelope.source) {
+    entries.push(envelope.source);
+  }
+
+  return entries.map(src => ({
+    github_url: src.repo.replace(/\.git$/, ''),
+    ref: src.commit,
+    path_prefix: src.language === 'rust' ? src.package : '',
+    language: src.language,
+  }));
+}
+
 export function parseAndNormalizeGraph(data: unknown): D3Graph {
   if (isSchema2Envelope(data)) {
-    return parseAndNormalizeGraph(data.data);
+    const sourceConfigs = extractSourceConfigs(data);
+    const graph = parseAndNormalizeGraph(data.data);
+    if (sourceConfigs.length > 0) {
+      graph.metadata.source_configs = sourceConfigs;
+    }
+    return graph;
   }
   if (isD3GraphFormat(data)) {
     return data;

web/src/main.ts

@@ -162,42 +162,54 @@ function showLargeGraphPrompt(fileSize: number): void {
 
 
 /**
- * Build a GitHub link to the source code
+ * Build a full-path string from a relative_path and optional prefix,
+ * avoiding duplication when the path already starts with the prefix.
  */
-function buildGitHubLink(node: D3Node): string | null {
-  if (!githubBaseUrl) return null;
-  
-  // Clean up the base URL (remove trailing slash)
-  const baseUrl = githubBaseUrl.replace(/\/$/, '');
-  
-  // Clean up path prefix (remove leading/trailing slashes)
-  const prefix = githubPathPrefix.replace(/^\/|\/$/g, '');
-  
-  // Build the full path, but avoid duplicating if relative_path already starts with prefix
-  let fullPath: string;
-  if (prefix) {
-    // Check if relative_path already starts with the prefix (avoid duplication)
-    if (node.relative_path.startsWith(prefix + '/') || node.relative_path === prefix) {
-      fullPath = node.relative_path;
-    } else {
-      fullPath = `${prefix}/${node.relative_path}`;
-    }
-  } else {
-    fullPath = node.relative_path;
+function buildFullPath(relativePath: string, prefix: string): string {
+  const cleanPrefix = prefix.replace(/^\/|\/$/g, '');
+  if (!cleanPrefix) return relativePath;
+  if (relativePath.startsWith(cleanPrefix + '/') || relativePath === cleanPrefix) {
+    return relativePath;
   }
-  
-  // Build the link with line numbers if available
-  let link = `${baseUrl}/blob/${githubBranch}/${fullPath}`;
-  
-  if (node.start_line) {
-    link += `#L${node.start_line}`;
-    // Only add end line if it's greater than start line (sanity check)
-    if (node.end_line && node.end_line > node.start_line) {
-      link += `-L${node.end_line}`;
+  return `${cleanPrefix}/${relativePath}`;
+}
+
+/**
+ * Append #L<start>-L<end> line-number fragment to a link.
+ */
+function appendLineFragment(link: string, start?: number, end?: number): string {
+  if (!start) return link;
+  link += `#L${start}`;
+  if (end && end > start) link += `-L${end}`;
+  return link;
+}
+
+/**
+ * Build a GitHub link to the source code.
+ * Prefers per-language source configs from the Schema 2.0 envelope,
+ * falling back to the global githubBaseUrl / githubBranch / githubPathPrefix.
+ */
+function buildGitHubLink(node: D3Node): string | null {
+  if (!node.relative_path) return null;
+
+  // Try per-language source config (from Schema 2.0 envelope metadata)
+  if (node.language && state.fullGraph?.metadata.source_configs) {
+    const config = state.fullGraph.metadata.source_configs.find(
+      c => c.language === node.language,
+    );
+    if (config) {
+      const fullPath = buildFullPath(node.relative_path, config.path_prefix);
+      const link = `${config.github_url}/blob/${config.ref}/${fullPath}`;
+      return appendLineFragment(link, node.start_line, node.end_line);
     }
   }
-  
-  return link;
+
+  // Fallback: global settings
+  if (!githubBaseUrl) return null;
+  const baseUrl = githubBaseUrl.replace(/\/$/, '');
+  const fullPath = buildFullPath(node.relative_path, githubPathPrefix);
+  const link = `${baseUrl}/blob/${githubBranch}/${fullPath}`;
+  return appendLineFragment(link, node.start_line, node.end_line);
 }
 
 /**

web/src/types.ts

@@ -179,12 +179,21 @@ export interface D3Link {
   type: LinkType | string;  // 'inner' | 'precondition' | 'postcondition' (or legacy 'calls')
 }
 
+/** Per-language GitHub source config derived from Schema 2.0 envelope inputs. */
+export interface SourceConfig {
+  github_url: string;
+  ref: string;
+  path_prefix: string;
+  language: string;
+}
+
 export interface D3GraphMetadata {
   total_nodes: number;
   total_edges: number;
   project_root: string;
   generated_at: string;
   github_url?: string;
+  source_configs?: SourceConfig[];
 }
 
 export interface D3Graph {