feat: Schema Visualizer, docs update & competitor comparison

* chore: add @xyflow/react, dagre, @types/dagre (Task 1)

* feat: add SchemaGraph, TableNode, GraphColumn, Relationship types (Task 2)

* feat: add SchemaGraph, TableNode, GraphColumn, Relationship Rust models (Task 3)

* feat: add cardinality color/label helpers and legend data (Task 4)

* feat: add schema_graph command skeleton with validation (Task 5)

* feat: add PostgreSQL schema graph query builder + cardinality inference (Task 6)

* feat: implement get_schema_graph for PostgreSQL + SQLite (Task 7)

* feat: add getSchemaGraph IPC wrapper (Task 8)

* feat: un-stub Schema Visualizer nav + add view branch placeholder (Task 9)

* feat: add SchemaVisualizerNode custom React Flow table card (Task 10)

* feat: add SchemaVisualizerPage with React Flow canvas (Task 11)

* feat: wire SchemaVisualizerPage + error handling + style polish (Tasks 12-14)

* perf: replace information_schema with pg_catalog for schema graph query (500x+ faster on remote PG)

* fix: add DB selector, ghost-style dropdowns, dark controls, minimap styling, attribution

* fix: always show schema selector, move attribution to top-left

* fix: SelectDropdown close on outside click works in React Flow (capture phase)

* style: remove border from attribution badge

* style: restore bg on attribution, no border

* fix: lower attribution z-index so dropdowns render above

* fix: ensure toolbar + dropdowns stack above canvas attribution

* feat: crow's foot markers on edges + collapsible legend

* fix: restore missing tableCount state (was overwritten by legendOpen)

* fix: move crow's foot marker defs inside ReactFlow SVG, remove duplicate external SVGs

* fix: inject crow's foot SVG markers into ReactFlow SVG via DOM ref

* fix: use hidden SVG before ReactFlow for crow's foot markers, remove DOM injection

* feat: custom CrowsFootEdge component with inline crow's foot markers

* feat: custom CrowsFootEdge with zero-or-one/zero-or-many notation + nullability-based cardinality

* fix: strip markers, use clean text labels only on edges

* fix: add SVG marker defs directly inside ReactFlow + url() references for crow's foot

* fix: use custom CrowsFootEdge with BaseEdge + inline SVG symbols (no marker defs needed)

* debug: add red/green circles at edge endpoints to verify custom edge renders

* fix: remove stale duplicate edge data, use clean data.startMarker/endMarker

* fix: use getSmoothStepPath offset points for correct tangent angle at endpoints

* fix: thicker strokeWidth, position at handle coords, use path tangents

* fix: use straight-line angle (not curve tangent) for marker rotation

* fix: compute marker positions directly with raw math, no SVG transforms

* fix: fixed-orientation symbols — | always vertical, crow's foot fans toward node

* fix: dead simple — | vertical line, ← or → horizontal crow's foot based on edge direction

* fix: increase marker gap to 12px so symbols aren't hidden behind handle dots

* fix: correct offset direction (away from card into gap), G=4

* fix: remove duplicate G offset inside Mark (was canceling out the call-site offset)

* fix: crow's foot back to fork shape — three lines converging to a tip

* fix: flip crow's foot direction

* fix: wider crow's foot spread (4→6)

* feat: add crow's foot symbols to relationship legend

* style: cleaner legend — horizontal edge with endpoint symbols + label

* feat: handles on both sides, edge builder picks closest side based on dagre layout

* fix: compute actual handle distances to pick shortest path

* revert: PK always left, FK always right — one handle per column only

* fix: lock edge marker direction via origRight, TB layout for horizontal spread, truncate long types

* fix: semi-transparent minimap mask, border stroke for viewport visibility

* feat: click edge to highlight (amber glow), all others dim to 15% opacity

* feat: legend highlights matching cardinality row when edge is clicked

* fix: crow's foot symbols now read color from edge style (amber when highlighted)

* fix: highlighted edge gets zIndex 1000 to render on top

* fix: folder empty message now checks unfiltered store, shows filter hint when connections exist but filtered out

* feat: flat SVG DB icons from simple-icons (PostgreSQL, MySQL, SQLite, Redis) replacing emoji

* chore: add *.db, *.sqlite, *.sqlite3 to .gitignore

* docs: update README with 3-way competitor comparison + current roadmap; update AGENTS.md schema visualizer status

src-tauri/src/models/db_viewer.rs

@@ -147,6 +147,50 @@ impl Change {
     }
 }
 
+/// Complete schema graph for the ER diagram visualizer.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SchemaGraph {
+    pub tables: Vec<TableNode>,
+    pub relationships: Vec<Relationship>,
+}
+
+/// A table node in the schema graph, including all columns.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TableNode {
+    pub name: String,
+    pub schema: String,
+    pub table_type: String,
+    pub columns: Vec<GraphColumn>,
+}
+
+/// Column metadata for schema graph visualization.
+///
+/// Includes PK/FK/UNIQUE flags and an optional foreign-key reference
+/// (referenced_schema, referenced_table, referenced_column).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GraphColumn {
+    pub name: String,
+    pub data_type: String,
+    pub is_pk: bool,
+    pub is_fk: bool,
+    pub is_unique: bool,
+    pub is_nullable: bool,
+    pub fk_ref: Option<(String, String, String)>,
+}
+
+/// A foreign-key relationship between two tables.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Relationship {
+    pub source_schema: String,
+    pub source_table: String,
+    pub source_column: String,
+    pub target_schema: String,
+    pub target_table: String,
+    pub target_column: String,
+    /// Inferred cardinality: "1:1", "1:N", or "N:M"
+    pub cardinality: String,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -335,4 +379,102 @@ mod tests {
         let json = serde_json::to_string(&info).unwrap();
         assert!(json.contains("pg_stat_statements"));
     }
+
+    #[test]
+    fn schema_graph_serialization() {
+        let graph = SchemaGraph {
+            tables: vec![TableNode {
+                name: "users".into(),
+                schema: "public".into(),
+                table_type: "TABLE".into(),
+                columns: vec![
+                    GraphColumn {
+                        name: "id".into(),
+                        data_type: "integer".into(),
+                        is_pk: true,
+                        is_fk: false,
+                        is_unique: true,
+                        is_nullable: false,
+                        fk_ref: None,
+                    },
+                    GraphColumn {
+                        name: "email".into(),
+                        data_type: "text".into(),
+                        is_pk: false,
+                        is_fk: false,
+                        is_unique: true,
+                        is_nullable: false,
+                        fk_ref: None,
+                    },
+                ],
+            }],
+            relationships: vec![Relationship {
+                source_schema: "public".into(),
+                source_table: "orders".into(),
+                source_column: "user_id".into(),
+                target_schema: "public".into(),
+                target_table: "users".into(),
+                target_column: "id".into(),
+                cardinality: "1:N".into(),
+            }],
+        };
+
+        let json = serde_json::to_string(&graph).unwrap();
+        assert!(json.contains("users"), "should contain table name");
+        assert!(json.contains("orders"), "should contain relationship source table");
+        assert!(json.contains("1:N"), "should contain cardinality");
+        assert!(json.contains("is_pk"), "should contain is_pk field");
+        assert!(json.contains("is_fk"), "should contain is_fk field");
+        assert!(json.contains("is_unique"), "should contain is_unique field");
+
+        // Round-trip deserialization
+        let parsed: SchemaGraph = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed.tables.len(), 1);
+        assert_eq!(parsed.tables[0].columns.len(), 2);
+        assert_eq!(parsed.relationships.len(), 1);
+        assert_eq!(parsed.relationships[0].cardinality, "1:N");
+    }
+
+    #[test]
+    fn schema_graph_empty_is_valid() {
+        let graph = SchemaGraph {
+            tables: vec![],
+            relationships: vec![],
+        };
+        let json = serde_json::to_string(&graph).unwrap();
+        let parsed: SchemaGraph = serde_json::from_str(&json).unwrap();
+        assert!(parsed.tables.is_empty());
+        assert!(parsed.relationships.is_empty());
+    }
+
+    #[test]
+    fn graph_column_fk_ref_serialization() {
+        // fk_ref = None
+        let col_none = GraphColumn {
+            name: "name".into(),
+            data_type: "text".into(),
+            is_pk: false,
+            is_fk: false,
+            is_unique: false,
+            is_nullable: false,
+            fk_ref: None,
+        };
+        let json = serde_json::to_string(&col_none).unwrap();
+        assert!(json.contains("null"), "fk_ref=None should serialize as null");
+
+        // fk_ref = Some(...)
+        let col_some = GraphColumn {
+            name: "user_id".into(),
+            data_type: "integer".into(),
+            is_pk: false,
+            is_fk: true,
+            is_unique: false,
+            is_nullable: false,
+            fk_ref: Some(("public".into(), "users".into(), "id".into())),
+        };
+        let json = serde_json::to_string(&col_some).unwrap();
+        assert!(json.contains("public"), "should contain referenced schema");
+        assert!(json.contains("users"), "should contain referenced table");
+        assert!(json.contains("id"), "should contain referenced column");
+    }
 }