时序图文档管理

Graph: A -> B -> C -> D
Query: "What nodes are reachable from A?"
Old (BROKEN): Returns only [B]  ❌
New (FIXED):  Returns [B, C, D] ✅

# OLD (BROKEN)
def get_forward_nodes(self, node_id, time_window_days=30):
    # Only checked direct edges
    for candidate in time_range:
        if self.has_edge(node_id, candidate):  # ❌ Only direct!
            results.append(candidate)

# NEW (FIXED)
def get_forward_nodes(self, node_id, time_window_days=30, max_hops=5):
    # Uses BFS to find ALL reachable nodes
    reachable = self._bfs_forward(node_id, max_hops, end_time)
    # Returns all nodes that can be reached, not just direct connections ✅

# OLD (BAD)
intersection = words1.intersection(words2)
union = words1.union(words2)
return len(intersection) / len(union)  # Jaccard - too simple!

# NEW (GOOD)
def similarity(self, text1: str, text2: str) -> float:
    vec1 = self.compute_tfidf_vector(text1)  # TF-IDF weighting
    vec2 = self.compute_tfidf_vector(text2)
    return self.cosine_similarity(vec1, vec2)  # Proper similarity

from totg_api import TOTGAPI
from datetime import datetime, timedelta

# Initialize
api = TOTGAPI()

# Add documents
api.add_document(
    doc_id="contract_001",
    content="Purchase agreement for equipment...",
    timestamp=datetime(2024, 1, 1),
    metadata={"type": "contract"}
)

api.add_document(
    doc_id="claim_001", 
    content="Formal claim for defects...",
    timestamp=datetime(2024, 2, 1),
    metadata={"type": "claim"}
)

# Add relationship
api.add_relationship("contract_001", "claim_001", relation_type="causal")

# Query: What happened after the contract?
future_docs = api.get_future_documents("contract_001", days=60)

# Query: What led to the claim?
past_docs = api.get_past_documents("claim_001", days=60)

# Find path between documents
path = api.find_path("contract_001", "claim_001")

# Compute attention (semantic relevance)
attention = api.compute_attention("contract_001", max_per_direction=10)

totg_core_fixed.py           # Fixed temporal graph with proper BFS navigation
totg_attention_fixed.py      # Fixed attention with TF-IDF similarity
totg_api.py                  # Production-ready API
totg_tests_comprehensive.py  # Complete test suite

# Run comprehensive tests
python3 totg_tests_comprehensive.py

# Expected output:
# ✓ PASS - All events found!
# ✓ PASS - Full chain found!
# ✓ PASS - Path found!
# 🎉 SUCCESS! All tests passed. System is production-ready!

# Run API example
python3 totg_api.py

Contract → Amendment → Acceptance → Claim → Response → Settlement → New Contract

api.get_future_documents("claim_001", days=60)
# Returns: [response_001, settlement_001]  ✅ Correct!

api.get_past_documents("settlement_001", days=90)
# Returns: [response, claim, acceptance, amendment, contract]  ✅ Full chain!

api.find_path("contract_001", "contract_002")
# Returns: ["contract_001", "contract_002"]  ✅ Direct causal link!

# Document management
api.add_document(doc_id, content, timestamp, metadata)
api.add_relationship(from_doc, to_doc, relation_type, weight)
api.get_document(doc_id)

# Temporal queries
api.get_documents_in_range(start_time, end_time)
api.get_future_documents(doc_id, days, max_results)
api.get_past_documents(doc_id, days, max_results)
api.find_path(from_doc, to_doc, max_hops)

# Attention queries
api.compute_attention(doc_id, max_per_direction)
api.find_related_documents(doc_id, max_results, direction)

# Analysis
api.get_statistics()
api.export_graph()
api.export_json(filepath)

# The API is designed for easy MCP wrapping:
- add_document() → MCP tool
- get_future_documents() → MCP tool
- compute_attention() → MCP tool

# Easy Flask/FastAPI wrapping:
@app.post("/api/documents")
def add_doc():
    return api.add_document(**request.json)

@app.get("/api/documents/{doc_id}/future")
def get_future(doc_id):
    return api.get_future_documents(doc_id)

# Direct usage:
from totg_api import TOTGAPI
api = TOTGAPI()
# Use directly in your code