Compare commits
2 Commits
feat/mnemo
...
feat/mnemo
| Author | SHA1 | Date | |
|---|---|---|---|
|
c961cf9122 | ||
|
|
a1c038672b |
@@ -477,10 +477,6 @@ index.html
|
||||
<div id="memory-inspect-panel" class="memory-inspect-panel" style="display:none;" aria-label="Memory Inspect Panel">
|
||||
</div>
|
||||
|
||||
<!-- Memory Connections Panel (Mnemosyne) -->
|
||||
<div id="memory-connections-panel" class="memory-connections-panel" style="display:none;" aria-label="Memory Connections Panel">
|
||||
</div>
|
||||
|
||||
<script>
|
||||
// ─── MNEMOSYNE: Memory Filter Panel ───────────────────
|
||||
function openMemoryFilter() {
|
||||
|
||||
@@ -1,291 +0,0 @@
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// MNEMOSYNE — Memory Connection Panel
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
//
|
||||
// Interactive panel for browsing, adding, and removing memory
|
||||
// connections. Opens as a sub-panel from MemoryInspect when
|
||||
// a memory crystal is selected.
|
||||
//
|
||||
// Usage from app.js:
|
||||
// MemoryConnections.init({
|
||||
// onNavigate: fn(memId), // fly to another memory
|
||||
// onConnectionChange: fn(memId, newConnections) // update hooks
|
||||
// });
|
||||
// MemoryConnections.show(memData, allMemories);
|
||||
// MemoryConnections.hide();
|
||||
//
|
||||
// Depends on: SpatialMemory (for updateMemory + highlightMemory)
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
const MemoryConnections = (() => {
|
||||
let _panel = null;
|
||||
let _onNavigate = null;
|
||||
let _onConnectionChange = null;
|
||||
let _currentMemId = null;
|
||||
let _hoveredConnId = null;
|
||||
|
||||
// ─── INIT ────────────────────────────────────────────────
|
||||
function init(opts = {}) {
|
||||
_onNavigate = opts.onNavigate || null;
|
||||
_onConnectionChange = opts.onConnectionChange || null;
|
||||
_panel = document.getElementById('memory-connections-panel');
|
||||
if (!_panel) {
|
||||
console.warn('[MemoryConnections] Panel element #memory-connections-panel not found in DOM');
|
||||
}
|
||||
}
|
||||
|
||||
// ─── SHOW ────────────────────────────────────────────────
|
||||
function show(memData, allMemories) {
|
||||
if (!_panel || !memData) return;
|
||||
|
||||
_currentMemId = memData.id;
|
||||
const connections = memData.connections || [];
|
||||
const connectedSet = new Set(connections);
|
||||
|
||||
// Build lookup for connected memories
|
||||
const memLookup = {};
|
||||
(allMemories || []).forEach(m => { memLookup[m.id] = m; });
|
||||
|
||||
// Connected memories list
|
||||
let connectedHtml = '';
|
||||
if (connections.length > 0) {
|
||||
connectedHtml = connections.map(cid => {
|
||||
const cm = memLookup[cid];
|
||||
const label = cm ? _truncate(cm.content || cid, 40) : cid;
|
||||
const cat = cm ? cm.category : '';
|
||||
const strength = cm ? Math.round((cm.strength || 0.7) * 100) : 70;
|
||||
return `
|
||||
<div class="mc-conn-item" data-memid="${_esc(cid)}">
|
||||
<div class="mc-conn-info">
|
||||
<span class="mc-conn-label" title="${_esc(cid)}">${_esc(label)}</span>
|
||||
<span class="mc-conn-meta">${_esc(cat)} · ${strength}%</span>
|
||||
</div>
|
||||
<div class="mc-conn-actions">
|
||||
<button class="mc-btn mc-btn-nav" data-nav="${_esc(cid)}" title="Navigate to memory">⮞</button>
|
||||
<button class="mc-btn mc-btn-remove" data-remove="${_esc(cid)}" title="Remove connection">✕</button>
|
||||
</div>
|
||||
</div>`;
|
||||
}).join('');
|
||||
} else {
|
||||
connectedHtml = '<div class="mc-empty">No connections yet</div>';
|
||||
}
|
||||
|
||||
// Find nearby unconnected memories (same region, then other regions)
|
||||
const suggestions = _findSuggestions(memData, allMemories, connectedSet);
|
||||
let suggestHtml = '';
|
||||
if (suggestions.length > 0) {
|
||||
suggestHtml = suggestions.map(s => {
|
||||
const label = _truncate(s.content || s.id, 36);
|
||||
const cat = s.category || '';
|
||||
const proximity = s._proximity || '';
|
||||
return `
|
||||
<div class="mc-suggest-item" data-memid="${_esc(s.id)}">
|
||||
<div class="mc-suggest-info">
|
||||
<span class="mc-suggest-label" title="${_esc(s.id)}">${_esc(label)}</span>
|
||||
<span class="mc-suggest-meta">${_esc(cat)} · ${_esc(proximity)}</span>
|
||||
</div>
|
||||
<button class="mc-btn mc-btn-add" data-add="${_esc(s.id)}" title="Add connection">+</button>
|
||||
</div>`;
|
||||
}).join('');
|
||||
} else {
|
||||
suggestHtml = '<div class="mc-empty">No nearby memories to connect</div>';
|
||||
}
|
||||
|
||||
_panel.innerHTML = `
|
||||
<div class="mc-header">
|
||||
<span class="mc-title">⬡ Connections</span>
|
||||
<button class="mc-close" id="mc-close-btn" aria-label="Close connections panel">✕</button>
|
||||
</div>
|
||||
<div class="mc-section">
|
||||
<div class="mc-section-label">LINKED (${connections.length})</div>
|
||||
<div class="mc-conn-list" id="mc-conn-list">${connectedHtml}</div>
|
||||
</div>
|
||||
<div class="mc-section">
|
||||
<div class="mc-section-label">SUGGESTED</div>
|
||||
<div class="mc-suggest-list" id="mc-suggest-list">${suggestHtml}</div>
|
||||
</div>
|
||||
`;
|
||||
|
||||
// Wire close button
|
||||
_panel.querySelector('#mc-close-btn')?.addEventListener('click', hide);
|
||||
|
||||
// Wire navigation buttons
|
||||
_panel.querySelectorAll('[data-nav]').forEach(btn => {
|
||||
btn.addEventListener('click', () => {
|
||||
if (_onNavigate) _onNavigate(btn.dataset.nav);
|
||||
});
|
||||
});
|
||||
|
||||
// Wire remove buttons
|
||||
_panel.querySelectorAll('[data-remove]').forEach(btn => {
|
||||
btn.addEventListener('click', () => _removeConnection(btn.dataset.remove));
|
||||
});
|
||||
|
||||
// Wire add buttons
|
||||
_panel.querySelectorAll('[data-add]').forEach(btn => {
|
||||
btn.addEventListener('click', () => _addConnection(btn.dataset.add));
|
||||
});
|
||||
|
||||
// Wire hover highlight for connection items
|
||||
_panel.querySelectorAll('.mc-conn-item').forEach(item => {
|
||||
item.addEventListener('mouseenter', () => _highlightConnection(item.dataset.memid));
|
||||
item.addEventListener('mouseleave', _clearConnectionHighlight);
|
||||
});
|
||||
|
||||
_panel.style.display = 'flex';
|
||||
requestAnimationFrame(() => _panel.classList.add('mc-visible'));
|
||||
}
|
||||
|
||||
// ─── HIDE ────────────────────────────────────────────────
|
||||
function hide() {
|
||||
if (!_panel) return;
|
||||
_clearConnectionHighlight();
|
||||
_panel.classList.remove('mc-visible');
|
||||
const onEnd = () => {
|
||||
_panel.style.display = 'none';
|
||||
_panel.removeEventListener('transitionend', onEnd);
|
||||
};
|
||||
_panel.addEventListener('transitionend', onEnd);
|
||||
setTimeout(() => { if (_panel) _panel.style.display = 'none'; }, 350);
|
||||
_currentMemId = null;
|
||||
}
|
||||
|
||||
// ─── SUGGESTION ENGINE ──────────────────────────────────
|
||||
function _findSuggestions(memData, allMemories, connectedSet) {
|
||||
if (!allMemories) return [];
|
||||
|
||||
const suggestions = [];
|
||||
const pos = memData.position || [0, 0, 0];
|
||||
const sameRegion = memData.category || 'working';
|
||||
|
||||
for (const m of allMemories) {
|
||||
if (m.id === memData.id) continue;
|
||||
if (connectedSet.has(m.id)) continue;
|
||||
|
||||
const mpos = m.position || [0, 0, 0];
|
||||
const dist = Math.sqrt(
|
||||
(pos[0] - mpos[0]) ** 2 +
|
||||
(pos[1] - mpos[1]) ** 2 +
|
||||
(pos[2] - mpos[2]) ** 2
|
||||
);
|
||||
|
||||
// Categorize proximity
|
||||
let proximity = 'nearby';
|
||||
if (m.category === sameRegion) {
|
||||
proximity = dist < 5 ? 'same region · close' : 'same region';
|
||||
} else {
|
||||
proximity = dist < 10 ? 'adjacent' : 'distant';
|
||||
}
|
||||
|
||||
suggestions.push({ ...m, _dist: dist, _proximity: proximity });
|
||||
}
|
||||
|
||||
// Sort: same region first, then by distance
|
||||
suggestions.sort((a, b) => {
|
||||
const aSame = a.category === sameRegion ? 0 : 1;
|
||||
const bSame = b.category === sameRegion ? 0 : 1;
|
||||
if (aSame !== bSame) return aSame - bSame;
|
||||
return a._dist - b._dist;
|
||||
});
|
||||
|
||||
return suggestions.slice(0, 8); // Cap at 8 suggestions
|
||||
}
|
||||
|
||||
// ─── CONNECTION ACTIONS ─────────────────────────────────
|
||||
function _addConnection(targetId) {
|
||||
if (!_currentMemId) return;
|
||||
|
||||
// Get current memory data via SpatialMemory
|
||||
const allMems = typeof SpatialMemory !== 'undefined' ? SpatialMemory.getAllMemories() : [];
|
||||
const current = allMems.find(m => m.id === _currentMemId);
|
||||
if (!current) return;
|
||||
|
||||
const conns = [...(current.connections || [])];
|
||||
if (conns.includes(targetId)) return;
|
||||
|
||||
conns.push(targetId);
|
||||
|
||||
// Update SpatialMemory
|
||||
if (typeof SpatialMemory !== 'undefined') {
|
||||
SpatialMemory.updateMemory(_currentMemId, { connections: conns });
|
||||
}
|
||||
|
||||
// Also create reverse connection on target
|
||||
const target = allMems.find(m => m.id === targetId);
|
||||
if (target) {
|
||||
const targetConns = [...(target.connections || [])];
|
||||
if (!targetConns.includes(_currentMemId)) {
|
||||
targetConns.push(_currentMemId);
|
||||
SpatialMemory.updateMemory(targetId, { connections: targetConns });
|
||||
}
|
||||
}
|
||||
|
||||
if (_onConnectionChange) _onConnectionChange(_currentMemId, conns);
|
||||
|
||||
// Re-render panel
|
||||
const updatedMem = { ...current, connections: conns };
|
||||
show(updatedMem, allMems);
|
||||
}
|
||||
|
||||
function _removeConnection(targetId) {
|
||||
if (!_currentMemId) return;
|
||||
|
||||
const allMems = typeof SpatialMemory !== 'undefined' ? SpatialMemory.getAllMemories() : [];
|
||||
const current = allMems.find(m => m.id === _currentMemId);
|
||||
if (!current) return;
|
||||
|
||||
const conns = (current.connections || []).filter(c => c !== targetId);
|
||||
|
||||
if (typeof SpatialMemory !== 'undefined') {
|
||||
SpatialMemory.updateMemory(_currentMemId, { connections: conns });
|
||||
}
|
||||
|
||||
// Also remove reverse connection
|
||||
const target = allMems.find(m => m.id === targetId);
|
||||
if (target) {
|
||||
const targetConns = (target.connections || []).filter(c => c !== _currentMemId);
|
||||
SpatialMemory.updateMemory(targetId, { connections: targetConns });
|
||||
}
|
||||
|
||||
if (_onConnectionChange) _onConnectionChange(_currentMemId, conns);
|
||||
|
||||
const updatedMem = { ...current, connections: conns };
|
||||
show(updatedMem, allMems);
|
||||
}
|
||||
|
||||
// ─── 3D HIGHLIGHT ───────────────────────────────────────
|
||||
function _highlightConnection(memId) {
|
||||
_hoveredConnId = memId;
|
||||
if (typeof SpatialMemory !== 'undefined') {
|
||||
SpatialMemory.highlightMemory(memId);
|
||||
}
|
||||
}
|
||||
|
||||
function _clearConnectionHighlight() {
|
||||
if (_hoveredConnId && typeof SpatialMemory !== 'undefined') {
|
||||
SpatialMemory.clearHighlight();
|
||||
}
|
||||
_hoveredConnId = null;
|
||||
}
|
||||
|
||||
// ─── HELPERS ────────────────────────────────────────────
|
||||
function _esc(str) {
|
||||
return String(str)
|
||||
.replace(/&/g, '&')
|
||||
.replace(/</g, '<')
|
||||
.replace(/>/g, '>')
|
||||
.replace(/"/g, '"');
|
||||
}
|
||||
|
||||
function _truncate(str, n) {
|
||||
return str.length > n ? str.slice(0, n - 1) + '\u2026' : str;
|
||||
}
|
||||
|
||||
function isOpen() {
|
||||
return _panel != null && _panel.style.display !== 'none';
|
||||
}
|
||||
|
||||
return { init, show, hide, isOpen };
|
||||
})();
|
||||
|
||||
export { MemoryConnections };
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -212,6 +212,65 @@ class MnemosyneArchive:
|
||||
def count(self) -> int:
|
||||
return len(self._entries)
|
||||
|
||||
def graph_data(
|
||||
self,
|
||||
topic_filter: Optional[str] = None,
|
||||
) -> dict:
|
||||
"""Export the full connection graph for 3D constellation visualization.
|
||||
|
||||
Returns a dict with:
|
||||
- nodes: list of {id, title, topics, source, created_at}
|
||||
- edges: list of {source, target, weight} from holographic links
|
||||
|
||||
Args:
|
||||
topic_filter: If set, only include entries matching this topic
|
||||
and edges between them.
|
||||
"""
|
||||
entries = list(self._entries.values())
|
||||
|
||||
if topic_filter:
|
||||
topic_lower = topic_filter.lower()
|
||||
entries = [
|
||||
e for e in entries
|
||||
if topic_lower in [t.lower() for t in e.topics]
|
||||
]
|
||||
|
||||
entry_ids = {e.id for e in entries}
|
||||
|
||||
nodes = [
|
||||
{
|
||||
"id": e.id,
|
||||
"title": e.title,
|
||||
"topics": e.topics,
|
||||
"source": e.source,
|
||||
"created_at": e.created_at,
|
||||
}
|
||||
for e in entries
|
||||
]
|
||||
|
||||
# Build edges from links, dedup (A→B and B→A become one edge)
|
||||
seen_edges: set[tuple[str, str]] = set()
|
||||
edges = []
|
||||
for e in entries:
|
||||
for linked_id in e.links:
|
||||
if linked_id not in entry_ids:
|
||||
continue
|
||||
pair = (min(e.id, linked_id), max(e.id, linked_id))
|
||||
if pair in seen_edges:
|
||||
continue
|
||||
seen_edges.add(pair)
|
||||
# Compute weight via linker for live similarity score
|
||||
linked = self._entries.get(linked_id)
|
||||
if linked:
|
||||
weight = self.linker.compute_similarity(e, linked)
|
||||
edges.append({
|
||||
"source": pair[0],
|
||||
"target": pair[1],
|
||||
"weight": round(weight, 4),
|
||||
})
|
||||
|
||||
return {"nodes": nodes, "edges": edges}
|
||||
|
||||
def stats(self) -> dict:
|
||||
entries = list(self._entries.values())
|
||||
total_links = sum(len(e.links) for e in entries)
|
||||
@@ -241,247 +300,3 @@ class MnemosyneArchive:
|
||||
"oldest_entry": oldest_entry,
|
||||
"newest_entry": newest_entry,
|
||||
}
|
||||
|
||||
def _build_adjacency(self) -> dict[str, set[str]]:
|
||||
"""Build adjacency dict from entry links. Only includes valid references."""
|
||||
adj: dict[str, set[str]] = {eid: set() for eid in self._entries}
|
||||
for eid, entry in self._entries.items():
|
||||
for linked_id in entry.links:
|
||||
if linked_id in self._entries and linked_id != eid:
|
||||
adj[eid].add(linked_id)
|
||||
adj[linked_id].add(eid)
|
||||
return adj
|
||||
|
||||
def graph_clusters(self, min_size: int = 1) -> list[dict]:
|
||||
"""Find connected component clusters in the holographic graph.
|
||||
|
||||
Uses BFS to discover groups of entries that are reachable from each
|
||||
other through their links. Returns clusters sorted by size descending.
|
||||
|
||||
Args:
|
||||
min_size: Minimum cluster size to include (filters out isolated entries).
|
||||
|
||||
Returns:
|
||||
List of dicts with keys: cluster_id, size, entries, topics, density
|
||||
"""
|
||||
adj = self._build_adjacency()
|
||||
visited: set[str] = set()
|
||||
clusters: list[dict] = []
|
||||
cluster_id = 0
|
||||
|
||||
for eid in self._entries:
|
||||
if eid in visited:
|
||||
continue
|
||||
# BFS from this entry
|
||||
component: list[str] = []
|
||||
queue = [eid]
|
||||
while queue:
|
||||
current = queue.pop(0)
|
||||
if current in visited:
|
||||
continue
|
||||
visited.add(current)
|
||||
component.append(current)
|
||||
for neighbor in adj.get(current, set()):
|
||||
if neighbor not in visited:
|
||||
queue.append(neighbor)
|
||||
|
||||
# Single-entry clusters are orphans
|
||||
if len(component) < min_size:
|
||||
continue
|
||||
|
||||
# Collect topics from cluster entries
|
||||
cluster_topics: dict[str, int] = {}
|
||||
internal_edges = 0
|
||||
for cid in component:
|
||||
entry = self._entries[cid]
|
||||
for t in entry.topics:
|
||||
cluster_topics[t] = cluster_topics.get(t, 0) + 1
|
||||
internal_edges += len(adj.get(cid, set()))
|
||||
internal_edges //= 2 # undirected, counted twice
|
||||
|
||||
# Density: actual edges / possible edges
|
||||
n = len(component)
|
||||
max_edges = n * (n - 1) // 2
|
||||
density = round(internal_edges / max_edges, 4) if max_edges > 0 else 0.0
|
||||
|
||||
# Top topics by frequency
|
||||
top_topics = sorted(cluster_topics.items(), key=lambda x: x[1], reverse=True)[:5]
|
||||
|
||||
clusters.append({
|
||||
"cluster_id": cluster_id,
|
||||
"size": n,
|
||||
"entries": component,
|
||||
"top_topics": [t for t, _ in top_topics],
|
||||
"internal_edges": internal_edges,
|
||||
"density": density,
|
||||
})
|
||||
cluster_id += 1
|
||||
|
||||
clusters.sort(key=lambda c: c["size"], reverse=True)
|
||||
return clusters
|
||||
|
||||
def hub_entries(self, limit: int = 10) -> list[dict]:
|
||||
"""Find the most connected entries (highest degree centrality).
|
||||
|
||||
These are the "hubs" of the holographic graph — entries that bridge
|
||||
many topics and attract many links.
|
||||
|
||||
Args:
|
||||
limit: Maximum number of hubs to return.
|
||||
|
||||
Returns:
|
||||
List of dicts with keys: entry, degree, inbound, outbound, topics
|
||||
"""
|
||||
adj = self._build_adjacency()
|
||||
inbound: dict[str, int] = {eid: 0 for eid in self._entries}
|
||||
|
||||
for entry in self._entries.values():
|
||||
for lid in entry.links:
|
||||
if lid in inbound:
|
||||
inbound[lid] += 1
|
||||
|
||||
hubs = []
|
||||
for eid, entry in self._entries.items():
|
||||
degree = len(adj.get(eid, set()))
|
||||
if degree == 0:
|
||||
continue
|
||||
hubs.append({
|
||||
"entry": entry,
|
||||
"degree": degree,
|
||||
"inbound": inbound.get(eid, 0),
|
||||
"outbound": len(entry.links),
|
||||
"topics": entry.topics,
|
||||
})
|
||||
|
||||
hubs.sort(key=lambda h: h["degree"], reverse=True)
|
||||
return hubs[:limit]
|
||||
|
||||
def bridge_entries(self) -> list[dict]:
|
||||
"""Find articulation points — entries whose removal would split a cluster.
|
||||
|
||||
These are "bridge" entries in the holographic graph. Removing them
|
||||
disconnects members that were previously reachable through the bridge.
|
||||
Uses Tarjan's algorithm for finding articulation points.
|
||||
|
||||
Returns:
|
||||
List of dicts with keys: entry, cluster_size, bridges_between
|
||||
"""
|
||||
adj = self._build_adjacency()
|
||||
|
||||
# Find clusters first
|
||||
clusters = self.graph_clusters(min_size=3)
|
||||
if not clusters:
|
||||
return []
|
||||
|
||||
# For each cluster, run Tarjan's algorithm
|
||||
bridges: list[dict] = []
|
||||
for cluster in clusters:
|
||||
members = set(cluster["entries"])
|
||||
if len(members) < 3:
|
||||
continue
|
||||
|
||||
# Build subgraph adjacency
|
||||
sub_adj = {eid: adj[eid] & members for eid in members}
|
||||
|
||||
# Tarjan's DFS for articulation points
|
||||
discovery: dict[str, int] = {}
|
||||
low: dict[str, int] = {}
|
||||
parent: dict[str, Optional[str]] = {}
|
||||
ap: set[str] = set()
|
||||
timer = [0]
|
||||
|
||||
def dfs(u: str):
|
||||
children = 0
|
||||
discovery[u] = low[u] = timer[0]
|
||||
timer[0] += 1
|
||||
for v in sub_adj[u]:
|
||||
if v not in discovery:
|
||||
children += 1
|
||||
parent[v] = u
|
||||
dfs(v)
|
||||
low[u] = min(low[u], low[v])
|
||||
|
||||
# u is AP if: root with 2+ children, or non-root with low[v] >= disc[u]
|
||||
if parent.get(u) is None and children > 1:
|
||||
ap.add(u)
|
||||
if parent.get(u) is not None and low[v] >= discovery[u]:
|
||||
ap.add(u)
|
||||
elif v != parent.get(u):
|
||||
low[u] = min(low[u], discovery[v])
|
||||
|
||||
for eid in members:
|
||||
if eid not in discovery:
|
||||
parent[eid] = None
|
||||
dfs(eid)
|
||||
|
||||
# For each articulation point, estimate what it bridges
|
||||
for ap_id in ap:
|
||||
ap_entry = self._entries[ap_id]
|
||||
# Remove it temporarily and count resulting components
|
||||
temp_adj = {k: v.copy() for k, v in sub_adj.items()}
|
||||
del temp_adj[ap_id]
|
||||
for k in temp_adj:
|
||||
temp_adj[k].discard(ap_id)
|
||||
|
||||
# BFS count components after removal
|
||||
temp_visited: set[str] = set()
|
||||
component_count = 0
|
||||
for mid in members:
|
||||
if mid == ap_id or mid in temp_visited:
|
||||
continue
|
||||
component_count += 1
|
||||
queue = [mid]
|
||||
while queue:
|
||||
cur = queue.pop(0)
|
||||
if cur in temp_visited:
|
||||
continue
|
||||
temp_visited.add(cur)
|
||||
for nb in temp_adj.get(cur, set()):
|
||||
if nb not in temp_visited:
|
||||
queue.append(nb)
|
||||
|
||||
if component_count > 1:
|
||||
bridges.append({
|
||||
"entry": ap_entry,
|
||||
"cluster_size": cluster["size"],
|
||||
"components_after_removal": component_count,
|
||||
"topics": ap_entry.topics,
|
||||
})
|
||||
|
||||
bridges.sort(key=lambda b: b["components_after_removal"], reverse=True)
|
||||
return bridges
|
||||
|
||||
def rebuild_links(self, threshold: Optional[float] = None) -> int:
|
||||
"""Recompute all links from scratch.
|
||||
|
||||
Clears existing links and re-applies the holographic linker to every
|
||||
entry pair. Useful after bulk ingestion or threshold changes.
|
||||
|
||||
Args:
|
||||
threshold: Override the linker's default similarity threshold.
|
||||
|
||||
Returns:
|
||||
Total number of links created.
|
||||
"""
|
||||
if threshold is not None:
|
||||
old_threshold = self.linker.threshold
|
||||
self.linker.threshold = threshold
|
||||
|
||||
# Clear all links
|
||||
for entry in self._entries.values():
|
||||
entry.links = []
|
||||
|
||||
entries = list(self._entries.values())
|
||||
total_links = 0
|
||||
|
||||
# Re-link each entry against all others
|
||||
for entry in entries:
|
||||
candidates = [e for e in entries if e.id != entry.id]
|
||||
new_links = self.linker.apply_links(entry, candidates)
|
||||
total_links += new_links
|
||||
|
||||
if threshold is not None:
|
||||
self.linker.threshold = old_threshold
|
||||
|
||||
self._save()
|
||||
return total_links
|
||||
|
||||
@@ -1,8 +1,7 @@
|
||||
"""CLI interface for Mnemosyne.
|
||||
|
||||
Provides: mnemosyne ingest, mnemosyne search, mnemosyne link, mnemosyne stats,
|
||||
mnemosyne topics, mnemosyne remove, mnemosyne export,
|
||||
mnemosyne clusters, mnemosyne hubs, mnemosyne bridges, mnemosyne rebuild
|
||||
mnemosyne topics, mnemosyne remove, mnemosyne export
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -91,58 +90,6 @@ def cmd_export(args):
|
||||
print(json.dumps(data, indent=2))
|
||||
|
||||
|
||||
def cmd_clusters(args):
|
||||
archive = MnemosyneArchive()
|
||||
clusters = archive.graph_clusters(min_size=args.min_size)
|
||||
if not clusters:
|
||||
print("No clusters found.")
|
||||
return
|
||||
for c in clusters:
|
||||
print(f"Cluster {c['cluster_id']}: {c['size']} entries, density={c['density']}")
|
||||
print(f" Topics: {', '.join(c['top_topics']) if c['top_topics'] else '(none)'}")
|
||||
if args.verbose:
|
||||
for eid in c["entries"]:
|
||||
entry = archive.get(eid)
|
||||
if entry:
|
||||
print(f" [{eid[:8]}] {entry.title}")
|
||||
print()
|
||||
|
||||
|
||||
def cmd_hubs(args):
|
||||
archive = MnemosyneArchive()
|
||||
hubs = archive.hub_entries(limit=args.limit)
|
||||
if not hubs:
|
||||
print("No hubs found.")
|
||||
return
|
||||
for h in hubs:
|
||||
e = h["entry"]
|
||||
print(f"[{e.id[:8]}] {e.title}")
|
||||
print(f" Degree: {h['degree']} (in: {h['inbound']}, out: {h['outbound']})")
|
||||
print(f" Topics: {', '.join(h['topics']) if h['topics'] else '(none)'}")
|
||||
print()
|
||||
|
||||
|
||||
def cmd_bridges(args):
|
||||
archive = MnemosyneArchive()
|
||||
bridges = archive.bridge_entries()
|
||||
if not bridges:
|
||||
print("No bridge entries found.")
|
||||
return
|
||||
for b in bridges:
|
||||
e = b["entry"]
|
||||
print(f"[{e.id[:8]}] {e.title}")
|
||||
print(f" Bridges {b['components_after_removal']} components (cluster: {b['cluster_size']} entries)")
|
||||
print(f" Topics: {', '.join(b['topics']) if b['topics'] else '(none)'}")
|
||||
print()
|
||||
|
||||
|
||||
def cmd_rebuild(args):
|
||||
archive = MnemosyneArchive()
|
||||
threshold = args.threshold if args.threshold else None
|
||||
total = archive.rebuild_links(threshold=threshold)
|
||||
print(f"Rebuilt links: {total} connections across {archive.count} entries")
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(prog="mnemosyne", description="The Living Holographic Archive")
|
||||
sub = parser.add_subparsers(dest="command")
|
||||
@@ -172,18 +119,6 @@ def main():
|
||||
ex.add_argument("-q", "--query", default="", help="Keyword filter")
|
||||
ex.add_argument("-t", "--topics", default="", help="Comma-separated topic filter")
|
||||
|
||||
cl = sub.add_parser("clusters", help="Show graph clusters (connected components)")
|
||||
cl.add_argument("-m", "--min-size", type=int, default=1, help="Minimum cluster size")
|
||||
cl.add_argument("-v", "--verbose", action="store_true", help="List entries in each cluster")
|
||||
|
||||
hu = sub.add_parser("hubs", help="Show most connected entries (hub analysis)")
|
||||
hu.add_argument("-n", "--limit", type=int, default=10, help="Max hubs to show")
|
||||
|
||||
sub.add_parser("bridges", help="Show bridge entries (articulation points)")
|
||||
|
||||
rb = sub.add_parser("rebuild", help="Recompute all links from scratch")
|
||||
rb.add_argument("-t", "--threshold", type=float, default=None, help="Similarity threshold override")
|
||||
|
||||
args = parser.parse_args()
|
||||
if not args.command:
|
||||
parser.print_help()
|
||||
@@ -197,10 +132,6 @@ def main():
|
||||
"topics": cmd_topics,
|
||||
"remove": cmd_remove,
|
||||
"export": cmd_export,
|
||||
"clusters": cmd_clusters,
|
||||
"hubs": cmd_hubs,
|
||||
"bridges": cmd_bridges,
|
||||
"rebuild": cmd_rebuild,
|
||||
}
|
||||
dispatch[args.command](args)
|
||||
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -262,6 +262,75 @@ def test_semantic_search_vs_keyword_relevance():
|
||||
assert results[0].title == "Python scripting"
|
||||
|
||||
|
||||
def test_graph_data_empty_archive():
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = Path(tmp) / "test_archive.json"
|
||||
archive = MnemosyneArchive(archive_path=path)
|
||||
data = archive.graph_data()
|
||||
assert data == {"nodes": [], "edges": []}
|
||||
|
||||
|
||||
def test_graph_data_nodes_and_edges():
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = Path(tmp) / "test_archive.json"
|
||||
archive = MnemosyneArchive(archive_path=path)
|
||||
e1 = ingest_event(archive, title="Python automation", content="Building automation tools in Python", topics=["code"])
|
||||
e2 = ingest_event(archive, title="Python scripting", content="Writing automation scripts using Python", topics=["code"])
|
||||
e3 = ingest_event(archive, title="Cooking", content="Making pasta carbonara", topics=["food"])
|
||||
|
||||
data = archive.graph_data()
|
||||
assert len(data["nodes"]) == 3
|
||||
# All node fields present
|
||||
for node in data["nodes"]:
|
||||
assert "id" in node
|
||||
assert "title" in node
|
||||
assert "topics" in node
|
||||
assert "source" in node
|
||||
assert "created_at" in node
|
||||
|
||||
# e1 and e2 should be linked (shared Python/automation tokens)
|
||||
edge_pairs = {(e["source"], e["target"]) for e in data["edges"]}
|
||||
e1e2 = (min(e1.id, e2.id), max(e1.id, e2.id))
|
||||
assert e1e2 in edge_pairs or (e1e2[1], e1e2[0]) in edge_pairs
|
||||
|
||||
# All edges have weights
|
||||
for edge in data["edges"]:
|
||||
assert "weight" in edge
|
||||
assert 0 <= edge["weight"] <= 1
|
||||
|
||||
|
||||
def test_graph_data_topic_filter():
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = Path(tmp) / "test_archive.json"
|
||||
archive = MnemosyneArchive(archive_path=path)
|
||||
e1 = ingest_event(archive, title="A", content="code stuff", topics=["code"])
|
||||
e2 = ingest_event(archive, title="B", content="more code", topics=["code"])
|
||||
ingest_event(archive, title="C", content="food stuff", topics=["food"])
|
||||
|
||||
data = archive.graph_data(topic_filter="code")
|
||||
node_ids = {n["id"] for n in data["nodes"]}
|
||||
assert e1.id in node_ids
|
||||
assert e2.id in node_ids
|
||||
assert len(data["nodes"]) == 2
|
||||
|
||||
|
||||
def test_graph_data_deduplicates_edges():
|
||||
"""Bidirectional links should produce a single edge, not two."""
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = Path(tmp) / "test_archive.json"
|
||||
archive = MnemosyneArchive(archive_path=path)
|
||||
e1 = ingest_event(archive, title="Python automation", content="Building automation tools in Python")
|
||||
e2 = ingest_event(archive, title="Python scripting", content="Writing automation scripts using Python")
|
||||
|
||||
data = archive.graph_data()
|
||||
# Count how many edges connect e1 and e2
|
||||
e1e2_edges = [
|
||||
e for e in data["edges"]
|
||||
if {e["source"], e["target"]} == {e1.id, e2.id}
|
||||
]
|
||||
assert len(e1e2_edges) <= 1, "Should not have duplicate bidirectional edges"
|
||||
|
||||
|
||||
def test_archive_topic_counts():
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = Path(tmp) / "test_archive.json"
|
||||
|
||||
@@ -1,271 +0,0 @@
|
||||
"""Tests for Mnemosyne graph cluster analysis features.
|
||||
|
||||
Tests: graph_clusters, hub_entries, bridge_entries, rebuild_links.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
|
||||
from nexus.mnemosyne.archive import MnemosyneArchive
|
||||
from nexus.mnemosyne.entry import ArchiveEntry
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def archive():
|
||||
"""Create a fresh archive in a temp directory."""
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = Path(tmp) / "test_archive.json"
|
||||
a = MnemosyneArchive(archive_path=path)
|
||||
yield a
|
||||
|
||||
|
||||
def _make_entry(title="Test", content="test content", topics=None):
|
||||
return ArchiveEntry(title=title, content=content, topics=topics or [])
|
||||
|
||||
|
||||
class TestGraphClusters:
|
||||
"""Test graph_clusters() connected component discovery."""
|
||||
|
||||
def test_empty_archive(self, archive):
|
||||
clusters = archive.graph_clusters()
|
||||
assert clusters == []
|
||||
|
||||
def test_single_orphan(self, archive):
|
||||
archive.add(_make_entry("Lone entry"), auto_link=False)
|
||||
# min_size=1 includes orphans
|
||||
clusters = archive.graph_clusters(min_size=1)
|
||||
assert len(clusters) == 1
|
||||
assert clusters[0]["size"] == 1
|
||||
assert clusters[0]["density"] == 0.0
|
||||
|
||||
def test_single_orphan_filtered(self, archive):
|
||||
archive.add(_make_entry("Lone entry"), auto_link=False)
|
||||
clusters = archive.graph_clusters(min_size=2)
|
||||
assert clusters == []
|
||||
|
||||
def test_two_linked_entries(self, archive):
|
||||
"""Two manually linked entries form a cluster."""
|
||||
e1 = archive.add(_make_entry("Alpha dogs", "canine training"), auto_link=False)
|
||||
e2 = archive.add(_make_entry("Beta cats", "feline behavior"), auto_link=False)
|
||||
# Manual link
|
||||
e1.links.append(e2.id)
|
||||
e2.links.append(e1.id)
|
||||
archive._save()
|
||||
|
||||
clusters = archive.graph_clusters(min_size=2)
|
||||
assert len(clusters) == 1
|
||||
assert clusters[0]["size"] == 2
|
||||
assert clusters[0]["internal_edges"] == 1
|
||||
assert clusters[0]["density"] == 1.0 # 1 edge out of 1 possible
|
||||
|
||||
def test_two_separate_clusters(self, archive):
|
||||
"""Two disconnected groups form separate clusters."""
|
||||
a1 = archive.add(_make_entry("AI models", "neural networks"), auto_link=False)
|
||||
a2 = archive.add(_make_entry("AI training", "gradient descent"), auto_link=False)
|
||||
b1 = archive.add(_make_entry("Cooking pasta", "italian recipes"), auto_link=False)
|
||||
b2 = archive.add(_make_entry("Cooking sauces", "tomato basil"), auto_link=False)
|
||||
|
||||
# Link cluster A
|
||||
a1.links.append(a2.id)
|
||||
a2.links.append(a1.id)
|
||||
# Link cluster B
|
||||
b1.links.append(b2.id)
|
||||
b2.links.append(b1.id)
|
||||
archive._save()
|
||||
|
||||
clusters = archive.graph_clusters(min_size=2)
|
||||
assert len(clusters) == 2
|
||||
sizes = sorted(c["size"] for c in clusters)
|
||||
assert sizes == [2, 2]
|
||||
|
||||
def test_cluster_topics(self, archive):
|
||||
"""Cluster includes aggregated topics."""
|
||||
e1 = archive.add(_make_entry("Alpha", "content", topics=["ai", "models"]), auto_link=False)
|
||||
e2 = archive.add(_make_entry("Beta", "content", topics=["ai", "training"]), auto_link=False)
|
||||
e1.links.append(e2.id)
|
||||
e2.links.append(e1.id)
|
||||
archive._save()
|
||||
|
||||
clusters = archive.graph_clusters(min_size=2)
|
||||
assert "ai" in clusters[0]["top_topics"]
|
||||
|
||||
def test_density_calculation(self, archive):
|
||||
"""Triangle (3 nodes, 3 edges) has density 1.0."""
|
||||
e1 = archive.add(_make_entry("A", "aaa"), auto_link=False)
|
||||
e2 = archive.add(_make_entry("B", "bbb"), auto_link=False)
|
||||
e3 = archive.add(_make_entry("C", "ccc"), auto_link=False)
|
||||
# Fully connected triangle
|
||||
for e, others in [(e1, [e2, e3]), (e2, [e1, e3]), (e3, [e1, e2])]:
|
||||
for o in others:
|
||||
e.links.append(o.id)
|
||||
archive._save()
|
||||
|
||||
clusters = archive.graph_clusters(min_size=2)
|
||||
assert len(clusters) == 1
|
||||
assert clusters[0]["internal_edges"] == 3
|
||||
assert clusters[0]["density"] == 1.0 # 3 edges / 3 possible
|
||||
|
||||
def test_chain_density(self, archive):
|
||||
"""A-B-C chain has density 2/3 (2 edges out of 3 possible)."""
|
||||
e1 = archive.add(_make_entry("A", "aaa"), auto_link=False)
|
||||
e2 = archive.add(_make_entry("B", "bbb"), auto_link=False)
|
||||
e3 = archive.add(_make_entry("C", "ccc"), auto_link=False)
|
||||
# Chain: A-B-C
|
||||
e1.links.append(e2.id)
|
||||
e2.links.extend([e1.id, e3.id])
|
||||
e3.links.append(e2.id)
|
||||
archive._save()
|
||||
|
||||
clusters = archive.graph_clusters(min_size=2)
|
||||
assert abs(clusters[0]["density"] - 2/3) < 0.01
|
||||
|
||||
|
||||
class TestHubEntries:
|
||||
"""Test hub_entries() degree centrality ranking."""
|
||||
|
||||
def test_empty(self, archive):
|
||||
assert archive.hub_entries() == []
|
||||
|
||||
def test_no_links(self, archive):
|
||||
archive.add(_make_entry("Lone"), auto_link=False)
|
||||
assert archive.hub_entries() == []
|
||||
|
||||
def test_hub_ordering(self, archive):
|
||||
"""Entry with most links is ranked first."""
|
||||
e1 = archive.add(_make_entry("Hub", "central node"), auto_link=False)
|
||||
e2 = archive.add(_make_entry("Spoke 1", "content"), auto_link=False)
|
||||
e3 = archive.add(_make_entry("Spoke 2", "content"), auto_link=False)
|
||||
e4 = archive.add(_make_entry("Spoke 3", "content"), auto_link=False)
|
||||
|
||||
# e1 connects to all spokes
|
||||
e1.links.extend([e2.id, e3.id, e4.id])
|
||||
e2.links.append(e1.id)
|
||||
e3.links.append(e1.id)
|
||||
e4.links.append(e1.id)
|
||||
archive._save()
|
||||
|
||||
hubs = archive.hub_entries()
|
||||
assert len(hubs) == 4
|
||||
assert hubs[0]["entry"].id == e1.id
|
||||
assert hubs[0]["degree"] == 3
|
||||
|
||||
def test_limit(self, archive):
|
||||
e1 = archive.add(_make_entry("A", ""), auto_link=False)
|
||||
e2 = archive.add(_make_entry("B", ""), auto_link=False)
|
||||
e1.links.append(e2.id)
|
||||
e2.links.append(e1.id)
|
||||
archive._save()
|
||||
|
||||
assert len(archive.hub_entries(limit=1)) == 1
|
||||
|
||||
def test_inbound_outbound(self, archive):
|
||||
"""Inbound counts links TO an entry, outbound counts links FROM it."""
|
||||
e1 = archive.add(_make_entry("Source", ""), auto_link=False)
|
||||
e2 = archive.add(_make_entry("Target", ""), auto_link=False)
|
||||
# Only e1 links to e2
|
||||
e1.links.append(e2.id)
|
||||
archive._save()
|
||||
|
||||
hubs = archive.hub_entries()
|
||||
h1 = next(h for h in hubs if h["entry"].id == e1.id)
|
||||
h2 = next(h for h in hubs if h["entry"].id == e2.id)
|
||||
assert h1["inbound"] == 0
|
||||
assert h1["outbound"] == 1
|
||||
assert h2["inbound"] == 1
|
||||
assert h2["outbound"] == 0
|
||||
|
||||
|
||||
class TestBridgeEntries:
|
||||
"""Test bridge_entries() articulation point detection."""
|
||||
|
||||
def test_empty(self, archive):
|
||||
assert archive.bridge_entries() == []
|
||||
|
||||
def test_no_bridges_in_triangle(self, archive):
|
||||
"""Fully connected triangle has no articulation points."""
|
||||
e1 = archive.add(_make_entry("A", ""), auto_link=False)
|
||||
e2 = archive.add(_make_entry("B", ""), auto_link=False)
|
||||
e3 = archive.add(_make_entry("C", ""), auto_link=False)
|
||||
for e, others in [(e1, [e2, e3]), (e2, [e1, e3]), (e3, [e1, e2])]:
|
||||
for o in others:
|
||||
e.links.append(o.id)
|
||||
archive._save()
|
||||
|
||||
assert archive.bridge_entries() == []
|
||||
|
||||
def test_bridge_in_chain(self, archive):
|
||||
"""A-B-C chain: B is the articulation point."""
|
||||
e1 = archive.add(_make_entry("A", ""), auto_link=False)
|
||||
e2 = archive.add(_make_entry("B", ""), auto_link=False)
|
||||
e3 = archive.add(_make_entry("C", ""), auto_link=False)
|
||||
e1.links.append(e2.id)
|
||||
e2.links.extend([e1.id, e3.id])
|
||||
e3.links.append(e2.id)
|
||||
archive._save()
|
||||
|
||||
bridges = archive.bridge_entries()
|
||||
assert len(bridges) == 1
|
||||
assert bridges[0]["entry"].id == e2.id
|
||||
assert bridges[0]["components_after_removal"] == 2
|
||||
|
||||
def test_no_bridges_in_small_cluster(self, archive):
|
||||
"""Two-node clusters are too small for bridge detection."""
|
||||
e1 = archive.add(_make_entry("A", ""), auto_link=False)
|
||||
e2 = archive.add(_make_entry("B", ""), auto_link=False)
|
||||
e1.links.append(e2.id)
|
||||
e2.links.append(e1.id)
|
||||
archive._save()
|
||||
|
||||
assert archive.bridge_entries() == []
|
||||
|
||||
|
||||
class TestRebuildLinks:
|
||||
"""Test rebuild_links() full recomputation."""
|
||||
|
||||
def test_empty_archive(self, archive):
|
||||
assert archive.rebuild_links() == 0
|
||||
|
||||
def test_creates_links(self, archive):
|
||||
"""Rebuild creates links between similar entries."""
|
||||
archive.add(_make_entry("Alpha dogs canine training", "obedience training"), auto_link=False)
|
||||
archive.add(_make_entry("Beta dogs canine behavior", "behavior training"), auto_link=False)
|
||||
archive.add(_make_entry("Cat food feline nutrition", "fish meals"), auto_link=False)
|
||||
|
||||
total = archive.rebuild_links()
|
||||
assert total > 0
|
||||
|
||||
# Check that dog entries are linked to each other
|
||||
entries = list(archive._entries.values())
|
||||
dog_entries = [e for e in entries if "dog" in e.title.lower()]
|
||||
assert any(len(e.links) > 0 for e in dog_entries)
|
||||
|
||||
def test_override_threshold(self, archive):
|
||||
"""Lower threshold creates more links."""
|
||||
archive.add(_make_entry("Alpha dogs", "training"), auto_link=False)
|
||||
archive.add(_make_entry("Beta cats", "training"), auto_link=False)
|
||||
archive.add(_make_entry("Gamma birds", "training"), auto_link=False)
|
||||
|
||||
# Very low threshold = more links
|
||||
low_links = archive.rebuild_links(threshold=0.01)
|
||||
|
||||
# Reset
|
||||
for e in archive._entries.values():
|
||||
e.links = []
|
||||
|
||||
# Higher threshold = fewer links
|
||||
high_links = archive.rebuild_links(threshold=0.9)
|
||||
|
||||
assert low_links >= high_links
|
||||
|
||||
def test_rebuild_persists(self, archive):
|
||||
"""Rebuild saves to disk."""
|
||||
archive.add(_make_entry("Alpha dogs", "training"), auto_link=False)
|
||||
archive.add(_make_entry("Beta dogs", "training"), auto_link=False)
|
||||
archive.rebuild_links()
|
||||
|
||||
# Reload and verify links survived
|
||||
archive2 = MnemosyneArchive(archive_path=archive.path)
|
||||
entries = list(archive2._entries.values())
|
||||
total_links = sum(len(e.links) for e in entries)
|
||||
assert total_links > 0
|
||||
160
style.css
160
style.css
@@ -1917,163 +1917,3 @@ canvas#nexus-canvas {
|
||||
background: rgba(74, 240, 192, 0.18);
|
||||
border-color: #4af0c0;
|
||||
}
|
||||
|
||||
/* ═══ MNEMOSYNE: Memory Connections Panel ═══ */
|
||||
.memory-connections-panel {
|
||||
position: fixed;
|
||||
top: 50%;
|
||||
right: 280px;
|
||||
transform: translateY(-50%) translateX(12px);
|
||||
width: 260px;
|
||||
max-height: 70vh;
|
||||
background: rgba(10, 12, 18, 0.92);
|
||||
border: 1px solid rgba(74, 240, 192, 0.15);
|
||||
border-radius: 8px;
|
||||
box-shadow: 0 8px 32px rgba(0,0,0,0.5);
|
||||
z-index: 310;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
opacity: 0;
|
||||
transition: opacity 0.2s ease, transform 0.2s ease;
|
||||
backdrop-filter: blur(8px);
|
||||
-webkit-backdrop-filter: blur(8px);
|
||||
font-family: var(--font-mono, monospace);
|
||||
}
|
||||
.memory-connections-panel.mc-visible {
|
||||
opacity: 1;
|
||||
transform: translateY(-50%) translateX(0);
|
||||
}
|
||||
|
||||
.mc-header {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
padding: 10px 14px;
|
||||
border-bottom: 1px solid rgba(255, 255, 255, 0.06);
|
||||
}
|
||||
.mc-title {
|
||||
color: rgba(74, 240, 192, 0.8);
|
||||
font-size: 11px;
|
||||
font-weight: 600;
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 0.5px;
|
||||
}
|
||||
.mc-close {
|
||||
background: none;
|
||||
border: none;
|
||||
color: rgba(255, 255, 255, 0.4);
|
||||
font-size: 14px;
|
||||
cursor: pointer;
|
||||
padding: 2px 6px;
|
||||
border-radius: 4px;
|
||||
line-height: 1;
|
||||
}
|
||||
.mc-close:hover {
|
||||
color: #fff;
|
||||
background: rgba(255, 255, 255, 0.1);
|
||||
}
|
||||
|
||||
.mc-section {
|
||||
padding: 8px 14px 10px;
|
||||
border-bottom: 1px solid rgba(255, 255, 255, 0.05);
|
||||
}
|
||||
.mc-section:last-child { border-bottom: none; }
|
||||
|
||||
.mc-section-label {
|
||||
color: rgba(74, 240, 192, 0.5);
|
||||
font-size: 9px;
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 1px;
|
||||
margin-bottom: 8px;
|
||||
}
|
||||
|
||||
.mc-conn-list, .mc-suggest-list {
|
||||
max-height: 200px;
|
||||
overflow-y: auto;
|
||||
}
|
||||
.mc-conn-list::-webkit-scrollbar, .mc-suggest-list::-webkit-scrollbar { width: 3px; }
|
||||
.mc-conn-list::-webkit-scrollbar-thumb, .mc-suggest-list::-webkit-scrollbar-thumb {
|
||||
background: rgba(74, 240, 192, 0.15);
|
||||
border-radius: 2px;
|
||||
}
|
||||
|
||||
.mc-conn-item, .mc-suggest-item {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
padding: 6px 8px;
|
||||
border-radius: 5px;
|
||||
margin-bottom: 4px;
|
||||
transition: background 0.15s ease;
|
||||
}
|
||||
.mc-conn-item:hover {
|
||||
background: rgba(74, 240, 192, 0.06);
|
||||
}
|
||||
.mc-suggest-item:hover {
|
||||
background: rgba(123, 92, 255, 0.06);
|
||||
}
|
||||
|
||||
.mc-conn-info, .mc-suggest-info {
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
overflow: hidden;
|
||||
}
|
||||
.mc-conn-label, .mc-suggest-label {
|
||||
display: block;
|
||||
color: var(--color-text, #ccc);
|
||||
font-size: 11px;
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
.mc-conn-meta, .mc-suggest-meta {
|
||||
display: block;
|
||||
color: rgba(255, 255, 255, 0.3);
|
||||
font-size: 9px;
|
||||
margin-top: 1px;
|
||||
}
|
||||
|
||||
.mc-conn-actions {
|
||||
display: flex;
|
||||
gap: 4px;
|
||||
flex-shrink: 0;
|
||||
margin-left: 8px;
|
||||
}
|
||||
|
||||
.mc-btn {
|
||||
background: none;
|
||||
border: 1px solid rgba(255, 255, 255, 0.12);
|
||||
color: rgba(255, 255, 255, 0.5);
|
||||
cursor: pointer;
|
||||
border-radius: 4px;
|
||||
font-size: 12px;
|
||||
padding: 2px 6px;
|
||||
line-height: 1;
|
||||
transition: all 0.15s ease;
|
||||
}
|
||||
.mc-btn-nav:hover {
|
||||
border-color: #4af0c0;
|
||||
color: #4af0c0;
|
||||
background: rgba(74, 240, 192, 0.08);
|
||||
}
|
||||
.mc-btn-remove:hover {
|
||||
border-color: #ff4466;
|
||||
color: #ff4466;
|
||||
background: rgba(255, 68, 102, 0.08);
|
||||
}
|
||||
.mc-btn-add {
|
||||
border-color: rgba(123, 92, 255, 0.3);
|
||||
color: rgba(123, 92, 255, 0.7);
|
||||
}
|
||||
.mc-btn-add:hover {
|
||||
border-color: #7b5cff;
|
||||
color: #7b5cff;
|
||||
background: rgba(123, 92, 255, 0.12);
|
||||
}
|
||||
|
||||
.mc-empty {
|
||||
color: rgba(255, 255, 255, 0.25);
|
||||
font-size: 11px;
|
||||
font-style: italic;
|
||||
padding: 4px 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user