splice 2.6.4

Span-safe refactoring kernel for 7 languages with Magellan code graph integration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;

/// A complete refactoring proof.
///
/// Contains before/after snapshots of the code graph, invariant checks,
/// and metadata for audit trails.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RefactoringProof {
    /// Proof metadata (operation, timestamp, etc.)
    pub metadata: ProofMetadata,
    /// Graph state before the refactoring
    pub before: GraphSnapshot,
    /// Graph state after the refactoring
    pub after: GraphSnapshot,
    /// Invariant validation results
    pub invariants: Vec<InvariantCheck>,
    /// Checksums for audit trail (added in 31-04)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub checksums: Option<ProofChecksums>,
}

/// Metadata about the proof.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProofMetadata {
    /// Operation type (e.g., "rename", "delete", "extract")
    pub operation: String,
    /// User who performed the operation (if available)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
    /// When the operation was performed
    pub timestamp: i64,
    /// Git commit hash (if available)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub git_commit: Option<String>,
    /// Splice version
    pub splice_version: String,
    /// Database path used for the operation
    pub database_path: PathBuf,
}

/// A snapshot of the code graph at a point in time.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GraphSnapshot {
    /// Snapshot timestamp
    pub timestamp: i64,
    /// All symbols in the graph
    pub symbols: HashMap<String, SymbolInfo>,
    /// All edges (caller -> callees)
    pub edges: HashMap<String, Vec<String>>,
    /// Entry points (roots of the call graph)
    pub entry_points: Vec<String>,
    /// Statistics about the snapshot
    pub stats: GraphStats,
}

/// Information about a symbol.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SymbolInfo {
    /// Unique symbol ID
    pub id: String,
    /// Symbol name
    pub name: String,
    /// File path
    pub file_path: String,
    /// Symbol kind (function, struct, etc.)
    pub kind: String,
    /// Byte span
    pub byte_span: (usize, usize),
    /// Number of incoming references (fan-in)
    pub fan_in: usize,
    /// Number of outgoing references (fan-out)
    pub fan_out: usize,
}

/// Statistics about a graph snapshot.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GraphStats {
    /// Total number of symbols
    pub total_symbols: usize,
    /// Total number of edges
    pub total_edges: usize,
    /// Number of entry points
    pub entry_point_count: usize,
    /// Maximum cyclomatic complexity (if available)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_complexity: Option<usize>,
}

/// Result of an invariant check.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InvariantCheck {
    /// Name of the invariant being checked
    pub invariant_name: String,
    /// Whether the invariant passed
    pub passed: bool,
    /// Violations found (empty if passed)
    pub violations: Vec<InvariantViolation>,
}

/// An invariant violation.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InvariantViolation {
    /// Severity of the violation
    pub severity: ViolationSeverity,
    /// Symbol or edge where violation occurred
    pub subject: String,
    /// Description of the violation
    pub message: String,
    /// Suggested fix (if applicable)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suggestion: Option<String>,
}

/// Severity of an invariant violation.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
pub enum ViolationSeverity {
    /// Informational (no impact on correctness)
    Info,
    /// Warning (may indicate a problem)
    Warning,
    /// Error (definitely breaks invariants)
    Error,
    /// Critical (makes the codebase unusable)
    Critical,
}

/// Checksums for proof integrity (added in 31-04).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProofChecksums {
    /// SHA-256 hash of the before snapshot
    pub before_hash: String,
    /// SHA-256 hash of the after snapshot
    pub after_hash: String,
    /// SHA-256 hash of the combined proof
    pub proof_hash: String,
}