refactor(structure): reorganize codebase into domain-focused modules

src/xref/mod.rs

@@ -0,0 +1,2 @@
+pub mod note_parser;
+pub mod references;

src/xref/note_parser.rs

@@ -0,0 +1,476 @@
+use std::sync::LazyLock;
+
+use regex::Regex;
+use rusqlite::Connection;
+use tracing::debug;
+
+use crate::core::error::Result;
+use crate::core::time::now_ms;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ParsedCrossRef {
+    pub reference_type: String,
+    pub target_entity_type: String,
+    pub target_iid: i64,
+    pub target_project_path: Option<String>,
+}
+
+#[derive(Debug, Default)]
+pub struct ExtractResult {
+    pub inserted: usize,
+    pub skipped_unresolvable: usize,
+    pub parse_failures: usize,
+}
+
+// GitLab system notes include the entity type word: "mentioned in issue #5"
+// or "mentioned in merge request !730". The word is mandatory in real data,
+// but we also keep the old bare-sigil form as a fallback (no data uses it today,
+// but other GitLab instances might differ).
+static MENTIONED_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(
+        r"mentioned in (?:issue |merge request )?(?:(?P<project>[\w][\w.\-]*(?:/[\w][\w.\-]*)+))?(?P<sigil>[#!])(?P<iid>\d+)",
+    )
+    .expect("mentioned regex is valid")
+});
+
+static CLOSED_BY_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(
+        r"closed by (?:issue |merge request )?(?:(?P<project>[\w][\w.\-]*(?:/[\w][\w.\-]*)+))?(?P<sigil>[#!])(?P<iid>\d+)",
+    )
+    .expect("closed_by regex is valid")
+});
+
+/// Matches full GitLab URLs like:
+/// `https://gitlab.example.com/group/project/-/issues/123`
+/// `https://gitlab.example.com/group/sub/project/-/merge_requests/456`
+static GITLAB_URL_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(
+        r"https?://[^\s/]+/(?P<project>[^\s]+?)/-/(?P<entity_type>issues|merge_requests)/(?P<iid>\d+)",
+    )
+    .expect("gitlab url regex is valid")
+});
+
+pub fn parse_cross_refs(body: &str) -> Vec<ParsedCrossRef> {
+    let mut refs = Vec::new();
+
+    for caps in MENTIONED_RE.captures_iter(body) {
+        if let Some(parsed) = capture_to_cross_ref(&caps, "mentioned") {
+            refs.push(parsed);
+        }
+    }
+
+    for caps in CLOSED_BY_RE.captures_iter(body) {
+        if let Some(parsed) = capture_to_cross_ref(&caps, "closes") {
+            refs.push(parsed);
+        }
+    }
+
+    refs
+}
+
+/// Extract cross-references from GitLab URLs in free-text bodies (descriptions, user notes).
+pub fn parse_url_refs(body: &str) -> Vec<ParsedCrossRef> {
+    let mut refs = Vec::new();
+    let mut seen = std::collections::HashSet::new();
+
+    for caps in GITLAB_URL_RE.captures_iter(body) {
+        let Some(entity_type_raw) = caps.name("entity_type").map(|m| m.as_str()) else {
+            continue;
+        };
+        let Some(iid_str) = caps.name("iid").map(|m| m.as_str()) else {
+            continue;
+        };
+        let Some(project) = caps.name("project").map(|m| m.as_str()) else {
+            continue;
+        };
+        let Ok(iid) = iid_str.parse::<i64>() else {
+            continue;
+        };
+
+        let target_entity_type = match entity_type_raw {
+            "issues" => "issue",
+            "merge_requests" => "merge_request",
+            _ => continue,
+        };
+
+        let key = (target_entity_type, project.to_owned(), iid);
+        if !seen.insert(key) {
+            continue; // deduplicate within same body
+        }
+
+        refs.push(ParsedCrossRef {
+            reference_type: "mentioned".to_owned(),
+            target_entity_type: target_entity_type.to_owned(),
+            target_iid: iid,
+            target_project_path: Some(project.to_owned()),
+        });
+    }
+
+    refs
+}
+
+fn capture_to_cross_ref(
+    caps: &regex::Captures<'_>,
+    reference_type: &str,
+) -> Option<ParsedCrossRef> {
+    let sigil = caps.name("sigil")?.as_str();
+    let iid_str = caps.name("iid")?.as_str();
+    let iid: i64 = iid_str.parse().ok()?;
+    let project = caps.name("project").map(|m| m.as_str().to_owned());
+
+    let target_entity_type = match sigil {
+        "#" => "issue",
+        "!" => "merge_request",
+        _ => return None,
+    };
+
+    Some(ParsedCrossRef {
+        reference_type: reference_type.to_owned(),
+        target_entity_type: target_entity_type.to_owned(),
+        target_iid: iid,
+        target_project_path: project,
+    })
+}
+
+struct SystemNote {
+    note_id: i64,
+    body: String,
+    noteable_type: String,
+    entity_id: i64,
+}
+
+pub fn extract_refs_from_system_notes(conn: &Connection, project_id: i64) -> Result<ExtractResult> {
+    let mut result = ExtractResult::default();
+
+    let mut stmt = conn.prepare_cached(
+        "SELECT n.id, n.body, d.noteable_type,
+                COALESCE(d.issue_id, d.merge_request_id) AS entity_id
+         FROM notes n
+         JOIN discussions d ON n.discussion_id = d.id
+         WHERE n.is_system = 1
+           AND n.project_id = ?1
+           AND n.body IS NOT NULL",
+    )?;
+
+    let notes: Vec<SystemNote> = stmt
+        .query_map([project_id], |row| {
+            Ok(SystemNote {
+                note_id: row.get(0)?,
+                body: row.get(1)?,
+                noteable_type: row.get(2)?,
+                entity_id: row.get(3)?,
+            })
+        })?
+        .collect::<std::result::Result<Vec<_>, _>>()?;
+
+    if notes.is_empty() {
+        return Ok(result);
+    }
+
+    let mut insert_stmt = conn.prepare_cached(
+        "INSERT OR IGNORE INTO entity_references
+         (project_id, source_entity_type, source_entity_id,
+          target_entity_type, target_entity_id,
+          target_project_path, target_entity_iid,
+          reference_type, source_method, created_at)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'note_parse', ?9)",
+    )?;
+
+    let now = now_ms();
+
+    for note in &notes {
+        let cross_refs = parse_cross_refs(&note.body);
+
+        if cross_refs.is_empty() {
+            debug!(
+                note_id = note.note_id,
+                body = %note.body,
+                "System note did not match any cross-reference pattern"
+            );
+            result.parse_failures += 1;
+            continue;
+        }
+
+        let source_entity_type = noteable_type_to_entity_type(&note.noteable_type);
+
+        for xref in &cross_refs {
+            let target_entity_id = if xref.target_project_path.is_none() {
+                resolve_entity_id(conn, project_id, &xref.target_entity_type, xref.target_iid)
+            } else {
+                resolve_cross_project_entity(
+                    conn,
+                    xref.target_project_path.as_deref().unwrap_or_default(),
+                    &xref.target_entity_type,
+                    xref.target_iid,
+                )
+            };
+
+            let rows_changed = insert_stmt.execute(rusqlite::params![
+                project_id,
+                source_entity_type,
+                note.entity_id,
+                xref.target_entity_type,
+                target_entity_id,
+                xref.target_project_path,
+                if target_entity_id.is_none() {
+                    Some(xref.target_iid)
+                } else {
+                    None
+                },
+                xref.reference_type,
+                now,
+            ])?;
+
+            if rows_changed > 0 {
+                if target_entity_id.is_none() {
+                    result.skipped_unresolvable += 1;
+                } else {
+                    result.inserted += 1;
+                }
+            }
+        }
+    }
+
+    if result.inserted > 0 || result.skipped_unresolvable > 0 {
+        debug!(
+            inserted = result.inserted,
+            unresolvable = result.skipped_unresolvable,
+            parse_failures = result.parse_failures,
+            "System note cross-reference extraction complete"
+        );
+    }
+
+    Ok(result)
+}
+
+fn noteable_type_to_entity_type(noteable_type: &str) -> &str {
+    match noteable_type {
+        "Issue" => "issue",
+        "MergeRequest" => "merge_request",
+        other => {
+            debug!(noteable_type = %other, "Unknown noteable_type, defaulting to issue");
+            "issue"
+        }
+    }
+}
+
+fn resolve_entity_id(
+    conn: &Connection,
+    project_id: i64,
+    entity_type: &str,
+    iid: i64,
+) -> Option<i64> {
+    let (table, id_col) = match entity_type {
+        "issue" => ("issues", "id"),
+        "merge_request" => ("merge_requests", "id"),
+        _ => return None,
+    };
+
+    let sql = format!("SELECT {id_col} FROM {table} WHERE project_id = ?1 AND iid = ?2");
+    conn.query_row(&sql, rusqlite::params![project_id, iid], |row| row.get(0))
+        .ok()
+}
+
+fn resolve_cross_project_entity(
+    conn: &Connection,
+    project_path: &str,
+    entity_type: &str,
+    iid: i64,
+) -> Option<i64> {
+    let project_id: i64 = conn
+        .query_row(
+            "SELECT id FROM projects WHERE path_with_namespace = ?1",
+            [project_path],
+            |row| row.get(0),
+        )
+        .ok()?;
+
+    resolve_entity_id(conn, project_id, entity_type, iid)
+}
+
+/// Extract cross-references from issue and MR descriptions (GitLab URLs only).
+pub fn extract_refs_from_descriptions(conn: &Connection, project_id: i64) -> Result<ExtractResult> {
+    let mut result = ExtractResult::default();
+
+    let mut insert_stmt = conn.prepare_cached(
+        "INSERT OR IGNORE INTO entity_references
+         (project_id, source_entity_type, source_entity_id,
+          target_entity_type, target_entity_id,
+          target_project_path, target_entity_iid,
+          reference_type, source_method, created_at)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'description_parse', ?9)",
+    )?;
+
+    let now = now_ms();
+
+    // Issues with descriptions
+    let mut issue_stmt = conn.prepare_cached(
+        "SELECT id, iid, description FROM issues
+         WHERE project_id = ?1 AND description IS NOT NULL AND description != ''",
+    )?;
+    let issues: Vec<(i64, i64, String)> = issue_stmt
+        .query_map([project_id], |row| {
+            Ok((row.get(0)?, row.get(1)?, row.get(2)?))
+        })?
+        .collect::<std::result::Result<Vec<_>, _>>()?;
+
+    for (entity_id, _iid, description) in &issues {
+        insert_url_refs(
+            conn,
+            &mut insert_stmt,
+            &mut result,
+            project_id,
+            "issue",
+            *entity_id,
+            description,
+            now,
+        )?;
+    }
+
+    // Merge requests with descriptions
+    let mut mr_stmt = conn.prepare_cached(
+        "SELECT id, iid, description FROM merge_requests
+         WHERE project_id = ?1 AND description IS NOT NULL AND description != ''",
+    )?;
+    let mrs: Vec<(i64, i64, String)> = mr_stmt
+        .query_map([project_id], |row| {
+            Ok((row.get(0)?, row.get(1)?, row.get(2)?))
+        })?
+        .collect::<std::result::Result<Vec<_>, _>>()?;
+
+    for (entity_id, _iid, description) in &mrs {
+        insert_url_refs(
+            conn,
+            &mut insert_stmt,
+            &mut result,
+            project_id,
+            "merge_request",
+            *entity_id,
+            description,
+            now,
+        )?;
+    }
+
+    if result.inserted > 0 || result.skipped_unresolvable > 0 {
+        debug!(
+            inserted = result.inserted,
+            unresolvable = result.skipped_unresolvable,
+            "Description cross-reference extraction complete"
+        );
+    }
+
+    Ok(result)
+}
+
+/// Extract cross-references from user (non-system) notes (GitLab URLs only).
+pub fn extract_refs_from_user_notes(conn: &Connection, project_id: i64) -> Result<ExtractResult> {
+    let mut result = ExtractResult::default();
+
+    let mut note_stmt = conn.prepare_cached(
+        "SELECT n.id, n.body, d.noteable_type,
+                COALESCE(d.issue_id, d.merge_request_id) AS entity_id
+         FROM notes n
+         JOIN discussions d ON n.discussion_id = d.id
+         WHERE n.is_system = 0
+           AND n.project_id = ?1
+           AND n.body IS NOT NULL",
+    )?;
+
+    let notes: Vec<(i64, String, String, i64)> = note_stmt
+        .query_map([project_id], |row| {
+            Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?))
+        })?
+        .collect::<std::result::Result<Vec<_>, _>>()?;
+
+    if notes.is_empty() {
+        return Ok(result);
+    }
+
+    let mut insert_stmt = conn.prepare_cached(
+        "INSERT OR IGNORE INTO entity_references
+         (project_id, source_entity_type, source_entity_id,
+          target_entity_type, target_entity_id,
+          target_project_path, target_entity_iid,
+          reference_type, source_method, created_at)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'note_parse', ?9)",
+    )?;
+
+    let now = now_ms();
+
+    for (_, body, noteable_type, entity_id) in &notes {
+        let source_entity_type = noteable_type_to_entity_type(noteable_type);
+        insert_url_refs(
+            conn,
+            &mut insert_stmt,
+            &mut result,
+            project_id,
+            source_entity_type,
+            *entity_id,
+            body,
+            now,
+        )?;
+    }
+
+    if result.inserted > 0 || result.skipped_unresolvable > 0 {
+        debug!(
+            inserted = result.inserted,
+            unresolvable = result.skipped_unresolvable,
+            "User note cross-reference extraction complete"
+        );
+    }
+
+    Ok(result)
+}
+
+/// Shared helper: parse URL refs from a body and insert into entity_references.
+#[allow(clippy::too_many_arguments)]
+fn insert_url_refs(
+    conn: &Connection,
+    insert_stmt: &mut rusqlite::CachedStatement<'_>,
+    result: &mut ExtractResult,
+    project_id: i64,
+    source_entity_type: &str,
+    source_entity_id: i64,
+    body: &str,
+    now: i64,
+) -> Result<()> {
+    let url_refs = parse_url_refs(body);
+
+    for xref in &url_refs {
+        let target_entity_id = if let Some(ref path) = xref.target_project_path {
+            resolve_cross_project_entity(conn, path, &xref.target_entity_type, xref.target_iid)
+        } else {
+            resolve_entity_id(conn, project_id, &xref.target_entity_type, xref.target_iid)
+        };
+
+        let rows_changed = insert_stmt.execute(rusqlite::params![
+            project_id,
+            source_entity_type,
+            source_entity_id,
+            xref.target_entity_type,
+            target_entity_id,
+            xref.target_project_path,
+            if target_entity_id.is_none() {
+                Some(xref.target_iid)
+            } else {
+                None
+            },
+            xref.reference_type,
+            now,
+        ])?;
+
+        if rows_changed > 0 {
+            if target_entity_id.is_none() {
+                result.skipped_unresolvable += 1;
+            } else {
+                result.inserted += 1;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "note_parser_tests.rs"]
+mod tests;

src/xref/note_parser_tests.rs

@@ -0,0 +1,770 @@
+use super::*;
+
+// --- parse_cross_refs: real GitLab system note format ---
+
+#[test]
+fn test_parse_mentioned_in_mr() {
+    let refs = parse_cross_refs("mentioned in merge request !567");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].reference_type, "mentioned");
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 567);
+    assert!(refs[0].target_project_path.is_none());
+}
+
+#[test]
+fn test_parse_mentioned_in_issue() {
+    let refs = parse_cross_refs("mentioned in issue #234");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].reference_type, "mentioned");
+    assert_eq!(refs[0].target_entity_type, "issue");
+    assert_eq!(refs[0].target_iid, 234);
+    assert!(refs[0].target_project_path.is_none());
+}
+
+#[test]
+fn test_parse_mentioned_cross_project() {
+    let refs = parse_cross_refs("mentioned in merge request group/repo!789");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].reference_type, "mentioned");
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 789);
+    assert_eq!(refs[0].target_project_path.as_deref(), Some("group/repo"));
+}
+
+#[test]
+fn test_parse_mentioned_cross_project_issue() {
+    let refs = parse_cross_refs("mentioned in issue group/repo#123");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].reference_type, "mentioned");
+    assert_eq!(refs[0].target_entity_type, "issue");
+    assert_eq!(refs[0].target_iid, 123);
+    assert_eq!(refs[0].target_project_path.as_deref(), Some("group/repo"));
+}
+
+#[test]
+fn test_parse_closed_by_mr() {
+    let refs = parse_cross_refs("closed by merge request !567");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].reference_type, "closes");
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 567);
+    assert!(refs[0].target_project_path.is_none());
+}
+
+#[test]
+fn test_parse_closed_by_cross_project() {
+    let refs = parse_cross_refs("closed by merge request group/repo!789");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].reference_type, "closes");
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 789);
+    assert_eq!(refs[0].target_project_path.as_deref(), Some("group/repo"));
+}
+
+#[test]
+fn test_parse_multiple_refs() {
+    let refs = parse_cross_refs("mentioned in merge request !123 and mentioned in issue #456");
+    assert_eq!(refs.len(), 2);
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 123);
+    assert_eq!(refs[1].target_entity_type, "issue");
+    assert_eq!(refs[1].target_iid, 456);
+}
+
+#[test]
+fn test_parse_no_refs() {
+    let refs = parse_cross_refs("Updated the description");
+    assert!(refs.is_empty());
+}
+
+#[test]
+fn test_parse_non_english_note() {
+    let refs = parse_cross_refs("a ajout\u{00e9} l'\u{00e9}tiquette ~bug");
+    assert!(refs.is_empty());
+}
+
+#[test]
+fn test_parse_multi_level_group_path() {
+    let refs = parse_cross_refs("mentioned in issue top/sub/project#123");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(
+        refs[0].target_project_path.as_deref(),
+        Some("top/sub/project")
+    );
+    assert_eq!(refs[0].target_iid, 123);
+}
+
+#[test]
+fn test_parse_deeply_nested_group_path() {
+    let refs = parse_cross_refs("mentioned in merge request a/b/c/d/e!42");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].target_project_path.as_deref(), Some("a/b/c/d/e"));
+    assert_eq!(refs[0].target_iid, 42);
+}
+
+#[test]
+fn test_parse_hyphenated_project_path() {
+    let refs = parse_cross_refs("mentioned in issue my-group/my-project#99");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(
+        refs[0].target_project_path.as_deref(),
+        Some("my-group/my-project")
+    );
+}
+
+#[test]
+fn test_parse_dotted_project_path() {
+    let refs = parse_cross_refs("mentioned in issue visiostack.io/backend#123");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(
+        refs[0].target_project_path.as_deref(),
+        Some("visiostack.io/backend")
+    );
+    assert_eq!(refs[0].target_iid, 123);
+}
+
+#[test]
+fn test_parse_dotted_nested_project_path() {
+    let refs = parse_cross_refs("closed by merge request my.org/sub.group/my.project!42");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(
+        refs[0].target_project_path.as_deref(),
+        Some("my.org/sub.group/my.project")
+    );
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 42);
+}
+
+// Bare-sigil fallback (no "issue"/"merge request" word) still works
+#[test]
+fn test_parse_bare_sigil_fallback() {
+    let refs = parse_cross_refs("mentioned in #123");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].target_iid, 123);
+    assert_eq!(refs[0].target_entity_type, "issue");
+}
+
+#[test]
+fn test_parse_bare_sigil_closed_by() {
+    let refs = parse_cross_refs("closed by !567");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].reference_type, "closes");
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 567);
+}
+
+#[test]
+fn test_parse_mixed_mentioned_and_closed() {
+    let refs = parse_cross_refs("mentioned in merge request !10 and closed by merge request !20");
+    assert_eq!(refs.len(), 2);
+    assert_eq!(refs[0].reference_type, "mentioned");
+    assert_eq!(refs[0].target_iid, 10);
+    assert_eq!(refs[1].reference_type, "closes");
+    assert_eq!(refs[1].target_iid, 20);
+}
+
+// --- parse_url_refs ---
+
+#[test]
+fn test_url_ref_same_project_issue() {
+    let refs = parse_url_refs(
+        "See https://gitlab.visiostack.com/vs/typescript-code/-/issues/3537 for details",
+    );
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].target_entity_type, "issue");
+    assert_eq!(refs[0].target_iid, 3537);
+    assert_eq!(
+        refs[0].target_project_path.as_deref(),
+        Some("vs/typescript-code")
+    );
+    assert_eq!(refs[0].reference_type, "mentioned");
+}
+
+#[test]
+fn test_url_ref_merge_request() {
+    let refs =
+        parse_url_refs("https://gitlab.visiostack.com/vs/typescript-code/-/merge_requests/3548");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 3548);
+    assert_eq!(
+        refs[0].target_project_path.as_deref(),
+        Some("vs/typescript-code")
+    );
+}
+
+#[test]
+fn test_url_ref_cross_project() {
+    let refs = parse_url_refs(
+        "Related: https://gitlab.visiostack.com/vs/python-code/-/merge_requests/5203",
+    );
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 5203);
+    assert_eq!(
+        refs[0].target_project_path.as_deref(),
+        Some("vs/python-code")
+    );
+}
+
+#[test]
+fn test_url_ref_with_anchor() {
+    let refs =
+        parse_url_refs("https://gitlab.visiostack.com/vs/typescript-code/-/issues/123#note_456");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].target_entity_type, "issue");
+    assert_eq!(refs[0].target_iid, 123);
+}
+
+#[test]
+fn test_url_ref_markdown_link() {
+    let refs = parse_url_refs(
+        "Check [this MR](https://gitlab.visiostack.com/vs/typescript-code/-/merge_requests/100) for context",
+    );
+    assert_eq!(refs.len(), 1);
+    assert_eq!(refs[0].target_entity_type, "merge_request");
+    assert_eq!(refs[0].target_iid, 100);
+}
+
+#[test]
+fn test_url_ref_multiple_urls() {
+    let body =
+        "See https://gitlab.com/a/b/-/issues/1 and https://gitlab.com/a/b/-/merge_requests/2";
+    let refs = parse_url_refs(body);
+    assert_eq!(refs.len(), 2);
+    assert_eq!(refs[0].target_entity_type, "issue");
+    assert_eq!(refs[0].target_iid, 1);
+    assert_eq!(refs[1].target_entity_type, "merge_request");
+    assert_eq!(refs[1].target_iid, 2);
+}
+
+#[test]
+fn test_url_ref_deduplicates() {
+    let body = "See https://gitlab.com/a/b/-/issues/1 and again https://gitlab.com/a/b/-/issues/1";
+    let refs = parse_url_refs(body);
+    assert_eq!(
+        refs.len(),
+        1,
+        "Duplicate URLs in same body should be deduplicated"
+    );
+}
+
+#[test]
+fn test_url_ref_non_gitlab_urls_ignored() {
+    let refs = parse_url_refs(
+        "Check https://google.com/search?q=test and https://github.com/org/repo/issues/1",
+    );
+    assert!(refs.is_empty());
+}
+
+#[test]
+fn test_url_ref_deeply_nested_project() {
+    let refs = parse_url_refs("https://gitlab.com/org/sub/deep/project/-/issues/42");
+    assert_eq!(refs.len(), 1);
+    assert_eq!(
+        refs[0].target_project_path.as_deref(),
+        Some("org/sub/deep/project")
+    );
+    assert_eq!(refs[0].target_iid, 42);
+}
+
+// --- Integration tests: system notes (updated for real format) ---
+
+fn setup_test_db() -> Connection {
+    use crate::core::db::{create_connection, run_migrations};
+
+    let conn = create_connection(std::path::Path::new(":memory:")).unwrap();
+    run_migrations(&conn).unwrap();
+    conn
+}
+
+fn seed_test_data(conn: &Connection) -> i64 {
+    let now = now_ms();
+
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (1, 100, 'group/test-project', 'https://gitlab.com/group/test-project', ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, project_id, iid, title, state, created_at, updated_at, last_seen_at)
+         VALUES (10, 1000, 1, 123, 'Test Issue', 'opened', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, project_id, iid, title, state, created_at, updated_at, last_seen_at)
+         VALUES (11, 1001, 1, 456, 'Another Issue', 'opened', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO merge_requests (id, gitlab_id, project_id, iid, title, state, source_branch, target_branch, author_username, created_at, updated_at, last_seen_at)
+         VALUES (20, 2000, 1, 789, 'Test MR', 'opened', 'feat', 'main', 'dev', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO discussions (id, gitlab_discussion_id, project_id, issue_id, noteable_type, last_seen_at)
+         VALUES (30, 'disc-aaa', 1, 10, 'Issue', ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO discussions (id, gitlab_discussion_id, project_id, merge_request_id, noteable_type, last_seen_at)
+         VALUES (31, 'disc-bbb', 1, 20, 'MergeRequest', ?1)",
+        [now],
+    )
+    .unwrap();
+
+    // System note: real GitLab format "mentioned in merge request !789"
+    conn.execute(
+        "INSERT INTO notes (id, gitlab_id, discussion_id, project_id, is_system, body, created_at, updated_at, last_seen_at)
+         VALUES (40, 4000, 30, 1, 1, 'mentioned in merge request !789', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    // System note: real GitLab format "mentioned in issue #456"
+    conn.execute(
+        "INSERT INTO notes (id, gitlab_id, discussion_id, project_id, is_system, body, created_at, updated_at, last_seen_at)
+         VALUES (41, 4001, 31, 1, 1, 'mentioned in issue #456', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    // User note (is_system=0) — should NOT be processed by system note extractor
+    conn.execute(
+        "INSERT INTO notes (id, gitlab_id, discussion_id, project_id, is_system, body, created_at, updated_at, last_seen_at)
+         VALUES (42, 4002, 30, 1, 0, 'mentioned in merge request !999', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    // System note with no cross-ref pattern
+    conn.execute(
+        "INSERT INTO notes (id, gitlab_id, discussion_id, project_id, is_system, body, created_at, updated_at, last_seen_at)
+         VALUES (43, 4003, 30, 1, 1, 'added label ~bug', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    // System note: cross-project ref
+    conn.execute(
+        "INSERT INTO notes (id, gitlab_id, discussion_id, project_id, is_system, body, created_at, updated_at, last_seen_at)
+         VALUES (44, 4004, 30, 1, 1, 'mentioned in issue other/project#999', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    1
+}
+
+#[test]
+fn test_extract_refs_from_system_notes_integration() {
+    let conn = setup_test_db();
+    let project_id = seed_test_data(&conn);
+
+    let result = extract_refs_from_system_notes(&conn, project_id).unwrap();
+
+    assert_eq!(result.inserted, 2, "Two same-project refs should resolve");
+    assert_eq!(
+        result.skipped_unresolvable, 1,
+        "One cross-project ref should be unresolvable"
+    );
+    assert_eq!(
+        result.parse_failures, 1,
+        "One system note has no cross-ref pattern"
+    );
+
+    let ref_count: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM entity_references WHERE project_id = ?1 AND source_method = 'note_parse'",
+            [project_id],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(ref_count, 3, "Should have 3 entity_references rows total");
+
+    let unresolved_count: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM entity_references WHERE target_entity_id IS NULL AND source_method = 'note_parse'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(
+        unresolved_count, 1,
+        "Should have 1 unresolved cross-project ref"
+    );
+
+    let (path, iid): (String, i64) = conn
+        .query_row(
+            "SELECT target_project_path, target_entity_iid FROM entity_references WHERE target_entity_id IS NULL",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
+        .unwrap();
+    assert_eq!(path, "other/project");
+    assert_eq!(iid, 999);
+}
+
+#[test]
+fn test_extract_refs_idempotent() {
+    let conn = setup_test_db();
+    let project_id = seed_test_data(&conn);
+
+    let result1 = extract_refs_from_system_notes(&conn, project_id).unwrap();
+    let result2 = extract_refs_from_system_notes(&conn, project_id).unwrap();
+
+    assert_eq!(result2.inserted, 0);
+    assert_eq!(result2.skipped_unresolvable, 0);
+
+    let total: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM entity_references WHERE source_method = 'note_parse'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(
+        total,
+        (result1.inserted + result1.skipped_unresolvable) as i64
+    );
+}
+
+#[test]
+fn test_extract_refs_empty_project() {
+    let conn = setup_test_db();
+    let result = extract_refs_from_system_notes(&conn, 999).unwrap();
+    assert_eq!(result.inserted, 0);
+    assert_eq!(result.skipped_unresolvable, 0);
+    assert_eq!(result.parse_failures, 0);
+}
+
+// --- Integration tests: description extraction ---
+
+#[test]
+fn test_extract_refs_from_descriptions_issue() {
+    let conn = setup_test_db();
+    let now = now_ms();
+
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (1, 100, 'vs/typescript-code', 'https://gitlab.com/vs/typescript-code', ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    // Issue with MR reference in description
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, project_id, iid, title, state, description, created_at, updated_at, last_seen_at)
+         VALUES (10, 1000, 1, 3537, 'Test Issue', 'opened',
+                 'Related to https://gitlab.com/vs/typescript-code/-/merge_requests/3548',
+                 ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    // The target MR so it resolves
+    conn.execute(
+        "INSERT INTO merge_requests (id, gitlab_id, project_id, iid, title, state, source_branch, target_branch, author_username, created_at, updated_at, last_seen_at)
+         VALUES (20, 2000, 1, 3548, 'Fix MR', 'merged', 'fix', 'main', 'dev', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    let result = extract_refs_from_descriptions(&conn, 1).unwrap();
+
+    assert_eq!(result.inserted, 1, "Should insert 1 description ref");
+    assert_eq!(result.skipped_unresolvable, 0);
+
+    let method: String = conn
+        .query_row(
+            "SELECT source_method FROM entity_references WHERE project_id = 1",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(method, "description_parse");
+}
+
+#[test]
+fn test_extract_refs_from_descriptions_mr() {
+    let conn = setup_test_db();
+    let now = now_ms();
+
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (1, 100, 'vs/typescript-code', 'https://gitlab.com/vs/typescript-code', ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, project_id, iid, title, state, created_at, updated_at, last_seen_at)
+         VALUES (10, 1000, 1, 100, 'Target Issue', 'opened', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO merge_requests (id, gitlab_id, project_id, iid, title, state, source_branch, target_branch, author_username, description, created_at, updated_at, last_seen_at)
+         VALUES (20, 2000, 1, 200, 'Fixing MR', 'merged', 'fix', 'main', 'dev',
+                 'Fixes https://gitlab.com/vs/typescript-code/-/issues/100',
+                 ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    let result = extract_refs_from_descriptions(&conn, 1).unwrap();
+
+    assert_eq!(result.inserted, 1);
+
+    let (src_type, tgt_type): (String, String) = conn
+        .query_row(
+            "SELECT source_entity_type, target_entity_type FROM entity_references WHERE project_id = 1",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
+        .unwrap();
+    assert_eq!(src_type, "merge_request");
+    assert_eq!(tgt_type, "issue");
+}
+
+#[test]
+fn test_extract_refs_from_descriptions_idempotent() {
+    let conn = setup_test_db();
+    let now = now_ms();
+
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (1, 100, 'vs/code', 'https://gitlab.com/vs/code', ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, project_id, iid, title, state, description, created_at, updated_at, last_seen_at)
+         VALUES (10, 1000, 1, 1, 'Issue', 'opened',
+                 'See https://gitlab.com/vs/code/-/merge_requests/2', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO merge_requests (id, gitlab_id, project_id, iid, title, state, source_branch, target_branch, author_username, created_at, updated_at, last_seen_at)
+         VALUES (20, 2000, 1, 2, 'MR', 'opened', 'x', 'main', 'dev', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    let r1 = extract_refs_from_descriptions(&conn, 1).unwrap();
+    assert_eq!(r1.inserted, 1);
+
+    let r2 = extract_refs_from_descriptions(&conn, 1).unwrap();
+    assert_eq!(r2.inserted, 0, "Second run should insert 0 (idempotent)");
+}
+
+#[test]
+fn test_extract_refs_from_descriptions_cross_project_unresolved() {
+    let conn = setup_test_db();
+    let now = now_ms();
+
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (1, 100, 'vs/typescript-code', 'https://gitlab.com/vs/typescript-code', ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, project_id, iid, title, state, description, created_at, updated_at, last_seen_at)
+         VALUES (10, 1000, 1, 1, 'Issue', 'opened',
+                 'See https://gitlab.com/vs/other-project/-/merge_requests/99', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    let result = extract_refs_from_descriptions(&conn, 1).unwrap();
+
+    assert_eq!(result.inserted, 0);
+    assert_eq!(
+        result.skipped_unresolvable, 1,
+        "Cross-project ref with no matching project should be unresolvable"
+    );
+
+    let (path, iid): (String, i64) = conn
+        .query_row(
+            "SELECT target_project_path, target_entity_iid FROM entity_references WHERE target_entity_id IS NULL",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
+        .unwrap();
+    assert_eq!(path, "vs/other-project");
+    assert_eq!(iid, 99);
+}
+
+// --- Integration tests: user note extraction ---
+
+#[test]
+fn test_extract_refs_from_user_notes_with_url() {
+    let conn = setup_test_db();
+    let now = now_ms();
+
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (1, 100, 'vs/code', 'https://gitlab.com/vs/code', ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, project_id, iid, title, state, created_at, updated_at, last_seen_at)
+         VALUES (10, 1000, 1, 50, 'Source Issue', 'opened', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO merge_requests (id, gitlab_id, project_id, iid, title, state, source_branch, target_branch, author_username, created_at, updated_at, last_seen_at)
+         VALUES (20, 2000, 1, 60, 'Target MR', 'opened', 'x', 'main', 'dev', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO discussions (id, gitlab_discussion_id, project_id, issue_id, noteable_type, last_seen_at)
+         VALUES (30, 'disc-user', 1, 10, 'Issue', ?1)",
+        [now],
+    )
+    .unwrap();
+
+    // User note with a URL
+    conn.execute(
+        "INSERT INTO notes (id, gitlab_id, discussion_id, project_id, is_system, body, created_at, updated_at, last_seen_at)
+         VALUES (40, 4000, 30, 1, 0,
+                 'This is related to https://gitlab.com/vs/code/-/merge_requests/60',
+                 ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    let result = extract_refs_from_user_notes(&conn, 1).unwrap();
+
+    assert_eq!(result.inserted, 1);
+
+    let method: String = conn
+        .query_row(
+            "SELECT source_method FROM entity_references WHERE project_id = 1",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(method, "note_parse");
+}
+
+#[test]
+fn test_extract_refs_from_user_notes_no_system_note_patterns() {
+    let conn = setup_test_db();
+    let now = now_ms();
+
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (1, 100, 'vs/code', 'https://gitlab.com/vs/code', ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, project_id, iid, title, state, created_at, updated_at, last_seen_at)
+         VALUES (10, 1000, 1, 50, 'Source', 'opened', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO merge_requests (id, gitlab_id, project_id, iid, title, state, source_branch, target_branch, author_username, created_at, updated_at, last_seen_at)
+         VALUES (20, 2000, 1, 999, 'Target', 'opened', 'x', 'main', 'dev', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO discussions (id, gitlab_discussion_id, project_id, issue_id, noteable_type, last_seen_at)
+         VALUES (30, 'disc-x', 1, 10, 'Issue', ?1)",
+        [now],
+    )
+    .unwrap();
+
+    // User note with system-note-like text but no URL — should NOT extract
+    // (user notes only use URL parsing, not system note pattern matching)
+    conn.execute(
+        "INSERT INTO notes (id, gitlab_id, discussion_id, project_id, is_system, body, created_at, updated_at, last_seen_at)
+         VALUES (40, 4000, 30, 1, 0, 'mentioned in merge request !999', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    let result = extract_refs_from_user_notes(&conn, 1).unwrap();
+
+    assert_eq!(
+        result.inserted, 0,
+        "User notes should only parse URLs, not system note patterns"
+    );
+}
+
+#[test]
+fn test_extract_refs_from_user_notes_idempotent() {
+    let conn = setup_test_db();
+    let now = now_ms();
+
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (1, 100, 'vs/code', 'https://gitlab.com/vs/code', ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, project_id, iid, title, state, created_at, updated_at, last_seen_at)
+         VALUES (10, 1000, 1, 1, 'Src', 'opened', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO merge_requests (id, gitlab_id, project_id, iid, title, state, source_branch, target_branch, author_username, created_at, updated_at, last_seen_at)
+         VALUES (20, 2000, 1, 2, 'Tgt', 'opened', 'x', 'main', 'dev', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO discussions (id, gitlab_discussion_id, project_id, issue_id, noteable_type, last_seen_at)
+         VALUES (30, 'disc-y', 1, 10, 'Issue', ?1)",
+        [now],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO notes (id, gitlab_id, discussion_id, project_id, is_system, body, created_at, updated_at, last_seen_at)
+         VALUES (40, 4000, 30, 1, 0,
+                 'See https://gitlab.com/vs/code/-/merge_requests/2', ?1, ?1, ?1)",
+        [now],
+    )
+    .unwrap();
+
+    let r1 = extract_refs_from_user_notes(&conn, 1).unwrap();
+    assert_eq!(r1.inserted, 1);
+
+    let r2 = extract_refs_from_user_notes(&conn, 1).unwrap();
+    assert_eq!(r2.inserted, 0, "Second extraction should be idempotent");
+}

src/xref/references.rs

@@ -0,0 +1,126 @@
+use rusqlite::{Connection, OptionalExtension};
+use tracing::info;
+
+use crate::core::error::Result;
+use crate::core::time::now_ms;
+
+pub fn extract_refs_from_state_events(conn: &Connection, project_id: i64) -> Result<usize> {
+    let changes = conn.execute(
+        "INSERT OR IGNORE INTO entity_references (
+            project_id,
+            source_entity_type, source_entity_id,
+            target_entity_type, target_entity_id,
+            reference_type, source_method, created_at
+        )
+        SELECT
+            rse.project_id,
+            'merge_request',
+            mr.id,
+            'issue',
+            rse.issue_id,
+            'closes',
+            'api',
+            rse.created_at
+        FROM resource_state_events rse
+        JOIN merge_requests mr
+            ON mr.project_id = rse.project_id
+            AND mr.iid = rse.source_merge_request_iid
+        WHERE rse.source_merge_request_iid IS NOT NULL
+          AND rse.issue_id IS NOT NULL
+          AND rse.project_id = ?1",
+        rusqlite::params![project_id],
+    )?;
+
+    if changes > 0 {
+        info!(
+            project_id,
+            references_inserted = changes,
+            "Extracted cross-references from state events"
+        );
+    }
+
+    Ok(changes)
+}
+
+#[derive(Debug, Clone)]
+pub struct EntityReference<'a> {
+    pub project_id: i64,
+    pub source_entity_type: &'a str,
+    pub source_entity_id: i64,
+    pub target_entity_type: &'a str,
+    pub target_entity_id: Option<i64>,
+    pub target_project_path: Option<&'a str>,
+    pub target_entity_iid: Option<i64>,
+    pub reference_type: &'a str,
+    pub source_method: &'a str,
+}
+
+pub fn insert_entity_reference(conn: &Connection, ref_: &EntityReference<'_>) -> Result<bool> {
+    let now = now_ms();
+    let changes = conn.execute(
+        "INSERT OR IGNORE INTO entity_references \
+         (project_id, source_entity_type, source_entity_id, \
+          target_entity_type, target_entity_id, target_project_path, target_entity_iid, \
+          reference_type, source_method, created_at) \
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
+        rusqlite::params![
+            ref_.project_id,
+            ref_.source_entity_type,
+            ref_.source_entity_id,
+            ref_.target_entity_type,
+            ref_.target_entity_id,
+            ref_.target_project_path,
+            ref_.target_entity_iid,
+            ref_.reference_type,
+            ref_.source_method,
+            now,
+        ],
+    )?;
+
+    Ok(changes > 0)
+}
+
+pub fn resolve_issue_local_id(
+    conn: &Connection,
+    project_id: i64,
+    issue_iid: i64,
+) -> Result<Option<i64>> {
+    let mut stmt =
+        conn.prepare_cached("SELECT id FROM issues WHERE project_id = ?1 AND iid = ?2")?;
+
+    let result = stmt
+        .query_row(rusqlite::params![project_id, issue_iid], |row| row.get(0))
+        .optional()?;
+
+    Ok(result)
+}
+
+pub fn resolve_project_path(conn: &Connection, gitlab_project_id: i64) -> Result<Option<String>> {
+    let mut stmt = conn
+        .prepare_cached("SELECT path_with_namespace FROM projects WHERE gitlab_project_id = ?1")?;
+
+    let result = stmt
+        .query_row(rusqlite::params![gitlab_project_id], |row| row.get(0))
+        .optional()?;
+
+    Ok(result)
+}
+
+pub fn count_references_for_source(
+    conn: &Connection,
+    source_entity_type: &str,
+    source_entity_id: i64,
+) -> Result<usize> {
+    let count: i64 = conn.query_row(
+        "SELECT COUNT(*) FROM entity_references \
+         WHERE source_entity_type = ?1 AND source_entity_id = ?2",
+        rusqlite::params![source_entity_type, source_entity_id],
+        |row| row.get(0),
+    )?;
+
+    Ok(count as usize)
+}
+
+#[cfg(test)]
+#[path = "references_tests.rs"]
+mod tests;

src/xref/references_tests.rs

@@ -0,0 +1,425 @@
+use super::*;
+use crate::core::db::{create_connection, run_migrations};
+use std::path::Path;
+
+fn setup_test_db() -> Connection {
+    let conn = create_connection(Path::new(":memory:")).unwrap();
+    run_migrations(&conn).unwrap();
+    conn
+}
+
+fn seed_project_issue_mr(conn: &Connection) -> (i64, i64, i64) {
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (1, 100, 'group/repo', 'https://gitlab.example.com/group/repo', 1000, 2000)",
+        [],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, iid, project_id, title, state, created_at, updated_at, last_seen_at)
+         VALUES (1, 200, 10, 1, 'Test issue', 'closed', 1000, 2000, 2000)",
+        [],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO merge_requests (id, gitlab_id, iid, project_id, title, state, created_at, updated_at, last_seen_at, source_branch, target_branch)
+         VALUES (1, 300, 5, 1, 'Test MR', 'merged', 1000, 2000, 2000, 'feature', 'main')",
+        [],
+    )
+    .unwrap();
+
+    (1, 1, 1)
+}
+
+#[test]
+fn test_extract_refs_from_state_events_basic() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, mr_id) = seed_project_issue_mr(&conn);
+
+    conn.execute(
+        "INSERT INTO resource_state_events
+         (gitlab_id, project_id, issue_id, merge_request_id, state,
+          created_at, source_merge_request_iid)
+         VALUES (1, ?1, ?2, NULL, 'closed', 3000, 5)",
+        rusqlite::params![project_id, issue_id],
+    )
+    .unwrap();
+
+    let count = extract_refs_from_state_events(&conn, project_id).unwrap();
+    assert_eq!(count, 1, "Should insert exactly one reference");
+
+    let (src_type, src_id, tgt_type, tgt_id, ref_type, method): (
+        String,
+        i64,
+        String,
+        i64,
+        String,
+        String,
+    ) = conn
+        .query_row(
+            "SELECT source_entity_type, source_entity_id,
+                    target_entity_type, target_entity_id,
+                    reference_type, source_method
+             FROM entity_references WHERE project_id = ?1",
+            [project_id],
+            |row| {
+                Ok((
+                    row.get(0)?,
+                    row.get(1)?,
+                    row.get(2)?,
+                    row.get(3)?,
+                    row.get(4)?,
+                    row.get(5)?,
+                ))
+            },
+        )
+        .unwrap();
+
+    assert_eq!(src_type, "merge_request");
+    assert_eq!(src_id, mr_id, "Source should be the MR's local DB id");
+    assert_eq!(tgt_type, "issue");
+    assert_eq!(tgt_id, issue_id, "Target should be the issue's local DB id");
+    assert_eq!(ref_type, "closes");
+    assert_eq!(method, "api");
+}
+
+#[test]
+fn test_extract_refs_dedup_with_closes_issues() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, mr_id) = seed_project_issue_mr(&conn);
+
+    conn.execute(
+        "INSERT INTO entity_references
+         (project_id, source_entity_type, source_entity_id,
+          target_entity_type, target_entity_id,
+          reference_type, source_method, created_at)
+         VALUES (?1, 'merge_request', ?2, 'issue', ?3, 'closes', 'api', 3000)",
+        rusqlite::params![project_id, mr_id, issue_id],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO resource_state_events
+         (gitlab_id, project_id, issue_id, merge_request_id, state,
+          created_at, source_merge_request_iid)
+         VALUES (1, ?1, ?2, NULL, 'closed', 3000, 5)",
+        rusqlite::params![project_id, issue_id],
+    )
+    .unwrap();
+
+    let count = extract_refs_from_state_events(&conn, project_id).unwrap();
+    assert_eq!(count, 0, "Should not insert duplicate reference");
+
+    let total: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM entity_references WHERE project_id = ?1",
+            [project_id],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(total, 1, "Should still have exactly one reference");
+}
+
+#[test]
+fn test_extract_refs_no_source_mr() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, _mr_id) = seed_project_issue_mr(&conn);
+
+    conn.execute(
+        "INSERT INTO resource_state_events
+         (gitlab_id, project_id, issue_id, merge_request_id, state,
+          created_at, source_merge_request_iid)
+         VALUES (1, ?1, ?2, NULL, 'closed', 3000, NULL)",
+        rusqlite::params![project_id, issue_id],
+    )
+    .unwrap();
+
+    let count = extract_refs_from_state_events(&conn, project_id).unwrap();
+    assert_eq!(count, 0, "Should not create refs when no source MR");
+}
+
+#[test]
+fn test_extract_refs_mr_not_synced() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, _mr_id) = seed_project_issue_mr(&conn);
+
+    conn.execute(
+        "INSERT INTO resource_state_events
+         (gitlab_id, project_id, issue_id, merge_request_id, state,
+          created_at, source_merge_request_iid)
+         VALUES (2, ?1, ?2, NULL, 'closed', 3000, 999)",
+        rusqlite::params![project_id, issue_id],
+    )
+    .unwrap();
+
+    let count = extract_refs_from_state_events(&conn, project_id).unwrap();
+    assert_eq!(
+        count, 0,
+        "Should not create ref when MR is not synced locally"
+    );
+}
+
+#[test]
+fn test_extract_refs_idempotent() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, _mr_id) = seed_project_issue_mr(&conn);
+
+    conn.execute(
+        "INSERT INTO resource_state_events
+         (gitlab_id, project_id, issue_id, merge_request_id, state,
+          created_at, source_merge_request_iid)
+         VALUES (1, ?1, ?2, NULL, 'closed', 3000, 5)",
+        rusqlite::params![project_id, issue_id],
+    )
+    .unwrap();
+
+    let count1 = extract_refs_from_state_events(&conn, project_id).unwrap();
+    assert_eq!(count1, 1);
+
+    let count2 = extract_refs_from_state_events(&conn, project_id).unwrap();
+    assert_eq!(count2, 0, "Second run should insert nothing (idempotent)");
+}
+
+#[test]
+fn test_extract_refs_multiple_events_same_mr_issue() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, _mr_id) = seed_project_issue_mr(&conn);
+
+    conn.execute(
+        "INSERT INTO resource_state_events
+         (gitlab_id, project_id, issue_id, merge_request_id, state,
+          created_at, source_merge_request_iid)
+         VALUES (1, ?1, ?2, NULL, 'closed', 3000, 5)",
+        rusqlite::params![project_id, issue_id],
+    )
+    .unwrap();
+    conn.execute(
+        "INSERT INTO resource_state_events
+         (gitlab_id, project_id, issue_id, merge_request_id, state,
+          created_at, source_merge_request_iid)
+         VALUES (2, ?1, ?2, NULL, 'closed', 4000, 5)",
+        rusqlite::params![project_id, issue_id],
+    )
+    .unwrap();
+
+    let count = extract_refs_from_state_events(&conn, project_id).unwrap();
+    assert!(count <= 2, "At most 2 inserts attempted");
+
+    let total: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM entity_references WHERE project_id = ?1",
+            [project_id],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(
+        total, 1,
+        "Only one unique reference should exist for same MR->issue pair"
+    );
+}
+
+#[test]
+fn test_extract_refs_scoped_to_project() {
+    let conn = setup_test_db();
+    seed_project_issue_mr(&conn);
+
+    conn.execute(
+        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace, web_url, created_at, updated_at)
+         VALUES (2, 101, 'group/other', 'https://gitlab.example.com/group/other', 1000, 2000)",
+        [],
+    )
+    .unwrap();
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, iid, project_id, title, state, created_at, updated_at, last_seen_at)
+         VALUES (2, 201, 10, 2, 'Other issue', 'closed', 1000, 2000, 2000)",
+        [],
+    )
+    .unwrap();
+    conn.execute(
+        "INSERT INTO merge_requests (id, gitlab_id, iid, project_id, title, state, created_at, updated_at, last_seen_at, source_branch, target_branch)
+         VALUES (2, 301, 5, 2, 'Other MR', 'merged', 1000, 2000, 2000, 'feature', 'main')",
+        [],
+    )
+    .unwrap();
+
+    conn.execute(
+        "INSERT INTO resource_state_events
+         (gitlab_id, project_id, issue_id, merge_request_id, state,
+          created_at, source_merge_request_iid)
+         VALUES (1, 1, 1, NULL, 'closed', 3000, 5)",
+        [],
+    )
+    .unwrap();
+    conn.execute(
+        "INSERT INTO resource_state_events
+         (gitlab_id, project_id, issue_id, merge_request_id, state,
+          created_at, source_merge_request_iid)
+         VALUES (2, 2, 2, NULL, 'closed', 3000, 5)",
+        [],
+    )
+    .unwrap();
+
+    let count = extract_refs_from_state_events(&conn, 1).unwrap();
+    assert_eq!(count, 1);
+
+    let total: i64 = conn
+        .query_row("SELECT COUNT(*) FROM entity_references", [], |row| {
+            row.get(0)
+        })
+        .unwrap();
+    assert_eq!(total, 1, "Only project 1 refs should be created");
+}
+
+#[test]
+fn test_insert_entity_reference_creates_row() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, mr_id) = seed_project_issue_mr(&conn);
+
+    let ref_ = EntityReference {
+        project_id,
+        source_entity_type: "merge_request",
+        source_entity_id: mr_id,
+        target_entity_type: "issue",
+        target_entity_id: Some(issue_id),
+        target_project_path: None,
+        target_entity_iid: None,
+        reference_type: "closes",
+        source_method: "api",
+    };
+
+    let inserted = insert_entity_reference(&conn, &ref_).unwrap();
+    assert!(inserted);
+
+    let count = count_references_for_source(&conn, "merge_request", mr_id).unwrap();
+    assert_eq!(count, 1);
+}
+
+#[test]
+fn test_insert_entity_reference_idempotent() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, mr_id) = seed_project_issue_mr(&conn);
+
+    let ref_ = EntityReference {
+        project_id,
+        source_entity_type: "merge_request",
+        source_entity_id: mr_id,
+        target_entity_type: "issue",
+        target_entity_id: Some(issue_id),
+        target_project_path: None,
+        target_entity_iid: None,
+        reference_type: "closes",
+        source_method: "api",
+    };
+
+    let first = insert_entity_reference(&conn, &ref_).unwrap();
+    assert!(first);
+
+    let second = insert_entity_reference(&conn, &ref_).unwrap();
+    assert!(!second, "Duplicate insert should be ignored");
+
+    let count = count_references_for_source(&conn, "merge_request", mr_id).unwrap();
+    assert_eq!(count, 1, "Still just one reference");
+}
+
+#[test]
+fn test_insert_entity_reference_cross_project_unresolved() {
+    let conn = setup_test_db();
+    let (project_id, _issue_id, mr_id) = seed_project_issue_mr(&conn);
+
+    let ref_ = EntityReference {
+        project_id,
+        source_entity_type: "merge_request",
+        source_entity_id: mr_id,
+        target_entity_type: "issue",
+        target_entity_id: None,
+        target_project_path: Some("other-group/other-project"),
+        target_entity_iid: Some(99),
+        reference_type: "closes",
+        source_method: "api",
+    };
+
+    let inserted = insert_entity_reference(&conn, &ref_).unwrap();
+    assert!(inserted);
+
+    let (target_id, target_path, target_iid): (Option<i64>, Option<String>, Option<i64>) = conn
+        .query_row(
+            "SELECT target_entity_id, target_project_path, target_entity_iid \
+             FROM entity_references WHERE source_entity_id = ?1",
+            [mr_id],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+        )
+        .unwrap();
+
+    assert!(target_id.is_none());
+    assert_eq!(target_path, Some("other-group/other-project".to_string()));
+    assert_eq!(target_iid, Some(99));
+}
+
+#[test]
+fn test_insert_multiple_closes_references() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, mr_id) = seed_project_issue_mr(&conn);
+
+    conn.execute(
+        "INSERT INTO issues (id, gitlab_id, iid, project_id, title, state, created_at, updated_at, last_seen_at)
+         VALUES (10, 210, 11, ?1, 'Second issue', 'opened', 1000, 2000, 2000)",
+        rusqlite::params![project_id],
+    )
+    .unwrap();
+    let issue_id_2 = 10i64;
+
+    for target_id in [issue_id, issue_id_2] {
+        let ref_ = EntityReference {
+            project_id,
+            source_entity_type: "merge_request",
+            source_entity_id: mr_id,
+            target_entity_type: "issue",
+            target_entity_id: Some(target_id),
+            target_project_path: None,
+            target_entity_iid: None,
+            reference_type: "closes",
+            source_method: "api",
+        };
+        insert_entity_reference(&conn, &ref_).unwrap();
+    }
+
+    let count = count_references_for_source(&conn, "merge_request", mr_id).unwrap();
+    assert_eq!(count, 2);
+}
+
+#[test]
+fn test_resolve_issue_local_id_found() {
+    let conn = setup_test_db();
+    let (project_id, issue_id, _mr_id) = seed_project_issue_mr(&conn);
+
+    let resolved = resolve_issue_local_id(&conn, project_id, 10).unwrap();
+    assert_eq!(resolved, Some(issue_id));
+}
+
+#[test]
+fn test_resolve_issue_local_id_not_found() {
+    let conn = setup_test_db();
+    let (project_id, _issue_id, _mr_id) = seed_project_issue_mr(&conn);
+
+    let resolved = resolve_issue_local_id(&conn, project_id, 999).unwrap();
+    assert!(resolved.is_none());
+}
+
+#[test]
+fn test_resolve_project_path_found() {
+    let conn = setup_test_db();
+    seed_project_issue_mr(&conn);
+
+    let path = resolve_project_path(&conn, 100).unwrap();
+    assert_eq!(path, Some("group/repo".to_string()));
+}
+
+#[test]
+fn test_resolve_project_path_not_found() {
+    let conn = setup_test_db();
+
+    let path = resolve_project_path(&conn, 999).unwrap();
+    assert!(path.is_none());
+}