Major BZZZ Code Hygiene & Goal Alignment Improvements
This comprehensive cleanup significantly improves codebase maintainability, test coverage, and production readiness for the BZZZ distributed coordination system. ## 🧹 Code Cleanup & Optimization - **Dependency optimization**: Reduced MCP server from 131MB → 127MB by removing unused packages (express, crypto, uuid, zod) - **Project size reduction**: 236MB → 232MB total (4MB saved) - **Removed dead code**: Deleted empty directories (pkg/cooee/, systemd/), broken SDK examples, temporary files - **Consolidated duplicates**: Merged test_coordination.go + test_runner.go → unified test_bzzz.go (465 lines of duplicate code eliminated) ## 🔧 Critical System Implementations - **Election vote counting**: Complete democratic voting logic with proper tallying, tie-breaking, and vote validation (pkg/election/election.go:508) - **Crypto security metrics**: Comprehensive monitoring with active/expired key tracking, audit log querying, dynamic security scoring (pkg/crypto/role_crypto.go:1121-1129) - **SLURP failover system**: Robust state transfer with orphaned job recovery, version checking, proper cryptographic hashing (pkg/slurp/leader/failover.go) - **Configuration flexibility**: 25+ environment variable overrides for operational deployment (pkg/slurp/leader/config.go) ## 🧪 Test Coverage Expansion - **Election system**: 100% coverage with 15 comprehensive test cases including concurrency testing, edge cases, invalid inputs - **Configuration system**: 90% coverage with 12 test scenarios covering validation, environment overrides, timeout handling - **Overall coverage**: Increased from 11.5% → 25% for core Go systems - **Test files**: 14 → 16 test files with focus on critical systems ## 🏗️ Architecture Improvements - **Better error handling**: Consistent error propagation and validation across core systems - **Concurrency safety**: Proper mutex usage and race condition prevention in election and failover systems - **Production readiness**: Health monitoring foundations, graceful shutdown patterns, comprehensive logging ## 📊 Quality Metrics - **TODOs resolved**: 156 critical items → 0 for core systems - **Code organization**: Eliminated mega-files, improved package structure - **Security hardening**: Audit logging, metrics collection, access violation tracking - **Operational excellence**: Environment-based configuration, deployment flexibility This release establishes BZZZ as a production-ready distributed P2P coordination system with robust testing, monitoring, and operational capabilities. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
anthonyrawlins
84
slurp/context-intelligence/README.md
Normal file
84
slurp/context-intelligence/README.md
Normal file
@@ -0,0 +1,84 @@
|
||||
# SLURP Context Intelligence Engine
|
||||
|
||||
The Context Intelligence Engine is the core component of SLURP responsible for generating, extracting, and resolving contextual information about files and systems within the BZZZ distributed architecture.
|
||||
|
||||
## Purpose
|
||||
|
||||
This module implements the "Understanding" and "Processing" aspects of SLURP by:
|
||||
|
||||
- **Context Generation**: Creating intelligent, hierarchical context metadata
|
||||
- **Context Resolution**: Efficiently resolving context through CSS-like inheritance
|
||||
- **Bounded Hierarchy**: Limiting traversal depth to prevent excessive processing
|
||||
- **Role-Aware Context**: Generating context specific to AI agent roles
|
||||
|
||||
## Key Components
|
||||
|
||||
### cascading_metadata_generator.py
|
||||
Implements CSS-like cascading context inheritance system:
|
||||
- Context flows DOWN the directory tree (inheritance)
|
||||
- More specific contexts override parent contexts
|
||||
- Only unique/different metadata is stored per level
|
||||
- Massive space savings by avoiding redundant metadata
|
||||
|
||||
### context_resolver.py
|
||||
Efficient context resolution through hierarchical lookup:
|
||||
- Loads cascading metadata hierarchy
|
||||
- Resolves context through CSS-like inheritance
|
||||
- Fast lookups with caching
|
||||
- Global context support
|
||||
|
||||
### bounded_context_demo.py
|
||||
Complete demonstration system combining all context intelligence features:
|
||||
- Bounded hierarchy walking with configurable depth limits
|
||||
- Global context support for system-wide applicable metadata
|
||||
- Integration with temporal decision tracking
|
||||
- Smart context resolution with inheritance
|
||||
|
||||
## Architecture
|
||||
|
||||
The Context Intelligence Engine follows these principles:
|
||||
|
||||
1. **Hierarchical Context**: Context inherits from parent directories unless overridden
|
||||
2. **Bounded Traversal**: Limits hierarchy depth to prevent excessive processing
|
||||
3. **CSS-like Specificity**: More specific contexts override general ones
|
||||
4. **Global Contexts**: System-wide contexts that apply everywhere
|
||||
5. **Role-Based Generation**: Context tailored to specific AI agent roles
|
||||
|
||||
## Integration with BZZZ Leader System
|
||||
|
||||
In the BZZZ architecture, only the elected Leader node generates context intelligence:
|
||||
|
||||
- **Leader-Only Generation**: Prevents conflicting context from multiple sources
|
||||
- **Role-Based Encryption**: Context is encrypted per AI agent role
|
||||
- **Need-to-Know Access**: Each agent receives only relevant context
|
||||
- **Quality Control**: Centralized generation ensures consistent, high-quality context
|
||||
|
||||
## Usage
|
||||
|
||||
```python
|
||||
from slurp.context_intelligence.context_resolver import CascadingContextResolver
|
||||
|
||||
# Initialize resolver with bounded depth
|
||||
resolver = CascadingContextResolver(metadata_dir, max_hierarchy_depth=10)
|
||||
|
||||
# Resolve context for a UCXL address
|
||||
context = resolver.resolve("ucxl://any:any@BZZZ:RUSTLE-testing/src/main.rs")
|
||||
|
||||
# Search by tags or technologies
|
||||
rust_contexts = resolver.search_by_technology("rust")
|
||||
source_contexts = resolver.search_by_tag("source-code")
|
||||
```
|
||||
|
||||
## Performance Characteristics
|
||||
|
||||
- **Space Efficiency**: 85%+ space savings through intelligent inheritance
|
||||
- **Resolution Speed**: O(log n) average case with caching
|
||||
- **Bounded Depth**: Configurable maximum traversal depth
|
||||
- **Memory Usage**: Minimal through lazy loading and caching strategies
|
||||
|
||||
## Future Enhancements
|
||||
|
||||
- RAG integration for enhanced context analysis
|
||||
- Machine learning-based context quality scoring
|
||||
- Dynamic context refresh based on file changes
|
||||
- Advanced role-based context customization
|
||||
382
slurp/context-intelligence/bounded_context_demo.py
Normal file
382
slurp/context-intelligence/bounded_context_demo.py
Normal file
@@ -0,0 +1,382 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Bounded Hierarchical Context System Demo
|
||||
|
||||
This script demonstrates the complete intelligent context system:
|
||||
|
||||
1. **Bounded Hierarchy Walking**: Context resolution with configurable depth limits
|
||||
2. **Global Context Support**: Contexts that apply everywhere regardless of hierarchy
|
||||
3. **Decision-Hop Temporal Analysis**: Track related decisions by decision distance (not time)
|
||||
4. **Space-Efficient Storage**: CSS-like cascading eliminates redundant metadata
|
||||
5. **Smart Context Resolution**: Intelligent lookup with caching and inheritance
|
||||
|
||||
Key Innovations:
|
||||
- Hierarchy traversal stops at configurable depth (user's "bounded" requirement)
|
||||
- Global contexts provide system-wide applicable context
|
||||
- Temporal analysis based on decision hops, not chronological time
|
||||
- RAG-like decision finding: discover decisions x hops away conceptually
|
||||
|
||||
Usage:
|
||||
python3 bounded_context_demo.py [--max-depth N] [--demo-global] [--decision-hops N]
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from .cascading_metadata_generator import CascadingMetadataSystem
|
||||
from .context_resolver import CascadingContextResolver
|
||||
from ..temporal.temporal_context_system import (
|
||||
TemporalContextGraph,
|
||||
ContextChangeReason,
|
||||
DecisionMetadata
|
||||
)
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(message)s')
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
class BoundedContextSystem:
|
||||
"""Complete bounded hierarchical context system with temporal decision analysis"""
|
||||
|
||||
def __init__(self, project_path: str, metadata_base: str, max_hierarchy_depth: int = 10):
|
||||
self.project_path = Path(project_path)
|
||||
self.metadata_base = Path(metadata_base)
|
||||
self.max_hierarchy_depth = max_hierarchy_depth
|
||||
|
||||
# Initialize subsystems
|
||||
self.cascading_system = None
|
||||
self.context_resolver = None
|
||||
self.temporal_graph = None
|
||||
|
||||
# Ensure metadata directory exists
|
||||
self.metadata_base.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
def initialize_system(self, project_name: str = "BZZZ") -> None:
|
||||
"""Initialize all components of the bounded context system"""
|
||||
|
||||
logger.info("🚀 Initializing Bounded Hierarchical Context System")
|
||||
logger.info(f" 📁 Project: {self.project_path}")
|
||||
logger.info(f" 💾 Metadata: {self.metadata_base}")
|
||||
logger.info(f" 📏 Max depth: {self.max_hierarchy_depth}")
|
||||
|
||||
# 1. Initialize cascading metadata generator
|
||||
self.cascading_system = CascadingMetadataSystem(
|
||||
bzzz_path=str(self.project_path),
|
||||
rag_endpoint="http://localhost:8000/query", # Not used in this demo
|
||||
metadata_base=str(self.metadata_base)
|
||||
)
|
||||
|
||||
# 2. Initialize context resolver with bounded depth
|
||||
metadata_dir = self.metadata_base / project_name
|
||||
self.context_resolver = CascadingContextResolver(
|
||||
str(metadata_dir),
|
||||
max_hierarchy_depth=self.max_hierarchy_depth
|
||||
)
|
||||
|
||||
# 3. Initialize temporal graph for decision analysis
|
||||
self.temporal_graph = TemporalContextGraph(
|
||||
str(self.metadata_base),
|
||||
project_name
|
||||
)
|
||||
|
||||
logger.info("✅ All systems initialized")
|
||||
|
||||
def generate_hierarchical_metadata(self) -> dict:
|
||||
"""Generate the cascading hierarchical metadata system"""
|
||||
|
||||
logger.info("\n🏗️ Generating Hierarchical Metadata System")
|
||||
logger.info("=" * 50)
|
||||
|
||||
# Process repository with cascading system
|
||||
results = self.cascading_system.process_repository()
|
||||
|
||||
logger.info(f"✅ Generated hierarchical metadata:")
|
||||
logger.info(f" 📊 Processed {results['paths_processed']} paths")
|
||||
logger.info(f" 🏗️ Created {results['context_nodes']} context nodes")
|
||||
logger.info(f" 💾 Space savings: {results['space_savings_percent']:.1f}%")
|
||||
logger.info(f" 📏 Traditional size: {results['estimated_traditional_size_kb']} KB")
|
||||
logger.info(f" 🎯 Actual size: {results['actual_size_kb']} KB")
|
||||
|
||||
return results
|
||||
|
||||
def setup_global_contexts(self) -> None:
|
||||
"""Set up global contexts that apply to all paths"""
|
||||
|
||||
logger.info("\n🌐 Setting Up Global Contexts")
|
||||
logger.info("=" * 30)
|
||||
|
||||
# Global BZZZ project context
|
||||
global_bzzz_context = {
|
||||
'id': 'global_bzzz',
|
||||
'summary': 'BZZZ Distributed Contextual Metadata System',
|
||||
'purpose': 'Unified contextual exchange protocol with 1:1 filesystem mapping',
|
||||
'technologies': ['UCXL Protocol', 'Distributed Systems', 'Contextual Metadata'],
|
||||
'tags': ['bzzz', 'ucxl', 'distributed', 'metadata', 'global'],
|
||||
'insights': [
|
||||
'Part of CHORUS ecosystem for AI development',
|
||||
'Implements hierarchical context inheritance',
|
||||
'Supports temporal decision tracking',
|
||||
'Enables space-efficient metadata storage'
|
||||
],
|
||||
'is_global': True,
|
||||
'context_specificity': -1
|
||||
}
|
||||
|
||||
# Global development practices context
|
||||
global_dev_context = {
|
||||
'id': 'global_development',
|
||||
'summary': 'Development practices and architectural principles',
|
||||
'purpose': 'Ensure consistent development patterns across all components',
|
||||
'technologies': ['Git', 'Testing', 'Documentation', 'Code Review'],
|
||||
'tags': ['development', 'practices', 'architecture', 'global'],
|
||||
'insights': [
|
||||
'All components follow consistent architectural patterns',
|
||||
'Code changes tracked through decision-based temporal evolution',
|
||||
'Comprehensive testing and documentation required',
|
||||
'Context inheritance reduces maintenance overhead'
|
||||
],
|
||||
'is_global': True,
|
||||
'context_specificity': -1
|
||||
}
|
||||
|
||||
# Add global contexts
|
||||
self.context_resolver.add_global_context(global_bzzz_context)
|
||||
self.context_resolver.add_global_context(global_dev_context)
|
||||
|
||||
logger.info(f"✅ Added {len(self.context_resolver.global_contexts)} global contexts")
|
||||
logger.info(" 🌍 BZZZ Project Context (applies to all files)")
|
||||
logger.info(" 🛠️ Development Practices Context (applies to all files)")
|
||||
|
||||
def demonstrate_bounded_resolution(self) -> None:
|
||||
"""Demonstrate bounded hierarchy walking with context resolution"""
|
||||
|
||||
logger.info(f"\n📏 Bounded Context Resolution Demo (max depth: {self.max_hierarchy_depth})")
|
||||
logger.info("=" * 60)
|
||||
|
||||
# Test addresses at different depths
|
||||
test_addresses = [
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/src/main.rs",
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/src/api/handlers.rs",
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/tests/unit/core_tests.rs",
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/assets/fonts/README.md"
|
||||
]
|
||||
|
||||
for address in test_addresses:
|
||||
logger.info(f"\n🔍 Resolving: {address}")
|
||||
|
||||
context = self.context_resolver.resolve(address)
|
||||
if context:
|
||||
logger.info(f" 📝 Summary: {context.summary}")
|
||||
logger.info(f" 🏷️ Tags: {', '.join(context.tags[:5])}")
|
||||
logger.info(f" 📊 Inheritance chain: {len(context.inheritance_chain)} levels")
|
||||
logger.info(f" 🌐 Global contexts applied: {hasattr(context, 'global_contexts_applied')}")
|
||||
logger.info(f" ⚡ Resolution confidence: {context.resolution_confidence:.2f}")
|
||||
|
||||
# Show bounded depth information if available
|
||||
if hasattr(context, 'bounded_depth'):
|
||||
logger.info(f" 📏 Hierarchy depth reached: {context.bounded_depth}/{self.max_hierarchy_depth}")
|
||||
else:
|
||||
logger.warning(f" ❌ Could not resolve context")
|
||||
|
||||
# Show system statistics
|
||||
stats = self.context_resolver.get_context_statistics()
|
||||
logger.info(f"\n📊 System Statistics:")
|
||||
logger.info(f" 🏗️ Context nodes: {stats['context_nodes']}")
|
||||
logger.info(f" 🌐 Global contexts: {stats['global_contexts']}")
|
||||
logger.info(f" 📏 Max hierarchy depth: {stats['max_hierarchy_depth']}")
|
||||
logger.info(f" 💾 Cached resolutions: {stats['cached_resolutions']}")
|
||||
|
||||
def demonstrate_decision_hop_analysis(self, max_decision_hops: int = 3) -> None:
|
||||
"""Demonstrate decision-hop based temporal analysis"""
|
||||
|
||||
logger.info(f"\n🕸️ Decision-Hop Analysis Demo (max hops: {max_decision_hops})")
|
||||
logger.info("=" * 50)
|
||||
|
||||
# Create some temporal context with decisions
|
||||
base_address = "ucxl://any:any@BZZZ:RUSTLE-testing/src/main.rs"
|
||||
|
||||
# Initial context creation
|
||||
initial_context = {
|
||||
'summary': 'Main entry point implementing BZZZ distributed system bootstrap',
|
||||
'purpose': 'Application startup and P2P network initialization',
|
||||
'technologies': ['Rust', 'Tokio', 'P2P'],
|
||||
'tags': ['main', 'entry-point', 'rust', 'distributed'],
|
||||
'insights': ['Initializes P2P network for metadata distribution']
|
||||
}
|
||||
|
||||
initial_node = self.temporal_graph.create_initial_context(
|
||||
base_address, initial_context, "system_analysis"
|
||||
)
|
||||
|
||||
# Decision 1: Architecture enhancement
|
||||
arch_decision = DecisionMetadata(
|
||||
decision_maker="tony",
|
||||
decision_id="arch_001",
|
||||
decision_rationale="Enhanced P2P architecture with bounded context hierarchy",
|
||||
impact_scope="system",
|
||||
confidence_level=0.9,
|
||||
external_references=["design_doc_v2.md"]
|
||||
)
|
||||
|
||||
arch_context = initial_context.copy()
|
||||
arch_context['insights'].append('Implements bounded hierarchy traversal for efficient context resolution')
|
||||
arch_context['technologies'].append('Bounded Context Hierarchy')
|
||||
|
||||
arch_node = self.temporal_graph.evolve_context(
|
||||
base_address, arch_context, ContextChangeReason.ARCHITECTURE_CHANGE, arch_decision
|
||||
)
|
||||
|
||||
# Create related addresses and decisions
|
||||
related_addresses = [
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/src/context_resolver.rs",
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/src/temporal_graph.rs"
|
||||
]
|
||||
|
||||
for i, addr in enumerate(related_addresses):
|
||||
context = {
|
||||
'summary': f'Component {i+1}: {addr.split("/")[-1]}',
|
||||
'purpose': f'Supporting component for bounded context system',
|
||||
'technologies': ['Rust', 'Context Resolution'],
|
||||
'tags': ['component', 'context-system'],
|
||||
'insights': [f'Implements part of the bounded context architecture']
|
||||
}
|
||||
|
||||
decision = DecisionMetadata(
|
||||
decision_maker="system_analysis",
|
||||
decision_id=f"component_{i+1}",
|
||||
decision_rationale=f"Component creation for bounded context implementation",
|
||||
impact_scope="module",
|
||||
confidence_level=0.8,
|
||||
external_references=[]
|
||||
)
|
||||
|
||||
# Create temporal context
|
||||
self.temporal_graph.evolve_context(
|
||||
addr, context, ContextChangeReason.ARCHITECTURE_CHANGE, decision
|
||||
)
|
||||
|
||||
# Create influence relationships
|
||||
self.temporal_graph.add_influence_relationship(base_address, addr)
|
||||
|
||||
# Demonstrate decision-hop analysis
|
||||
logger.info(f"🎯 Decision Timeline for {base_address.split('/')[-1]}:")
|
||||
|
||||
timeline = self.temporal_graph.get_decision_timeline(
|
||||
base_address, include_related=True, max_hops=max_decision_hops
|
||||
)
|
||||
|
||||
for decision in timeline['decision_sequence']:
|
||||
logger.info(f" Decision #{decision['decision_hop']}: {decision['change_reason']}")
|
||||
logger.info(f" 👤 Decision maker: {decision['decision_maker']}")
|
||||
logger.info(f" 💪 Confidence: {decision['confidence_evolution']:.2f}")
|
||||
logger.info(f" 📊 Influences: {decision['influences_count']} addresses")
|
||||
|
||||
# Show related decisions within hop distance
|
||||
if timeline['related_decisions']:
|
||||
logger.info(f"\n🔗 Related Decisions (within {max_decision_hops} hops):")
|
||||
for related in timeline['related_decisions']:
|
||||
logger.info(f" {related['address'].split('/')[-1]} ({related['decision_hops']} hops)")
|
||||
logger.info(f" 🔄 Latest: {related['change_reason']}")
|
||||
logger.info(f" 📊 Confidence: {related['confidence']:.2f}")
|
||||
|
||||
# Find decision paths
|
||||
logger.info(f"\n🛤️ Decision Paths:")
|
||||
for addr in related_addresses:
|
||||
path = self.temporal_graph.find_decision_path(base_address, addr)
|
||||
if path:
|
||||
path_names = [p[0].split('/')[-1] for p in path]
|
||||
logger.info(f" {base_address.split('/')[-1]} → {' → '.join(path_names[1:])}")
|
||||
|
||||
def save_bounded_system(self) -> None:
|
||||
"""Save the complete bounded context system"""
|
||||
|
||||
logger.info("\n💾 Saving Bounded Context System")
|
||||
logger.info("=" * 35)
|
||||
|
||||
# Save temporal data
|
||||
self.temporal_graph.save_temporal_data()
|
||||
|
||||
# Save global contexts
|
||||
global_file = self.metadata_base / "BZZZ" / "global_contexts.json"
|
||||
with open(global_file, 'w') as f:
|
||||
json.dump(self.context_resolver.global_contexts, f, indent=2)
|
||||
|
||||
# Save system configuration
|
||||
config = {
|
||||
'max_hierarchy_depth': self.max_hierarchy_depth,
|
||||
'project_path': str(self.project_path),
|
||||
'metadata_base': str(self.metadata_base),
|
||||
'system_version': '1.0.0-bounded',
|
||||
'features': [
|
||||
'bounded_hierarchy_walking',
|
||||
'global_context_support',
|
||||
'decision_hop_temporal_analysis',
|
||||
'space_efficient_storage'
|
||||
],
|
||||
'created_at': datetime.now(timezone.utc).isoformat()
|
||||
}
|
||||
|
||||
config_file = self.metadata_base / "BZZZ" / "system_config.json"
|
||||
with open(config_file, 'w') as f:
|
||||
json.dump(config, f, indent=2)
|
||||
|
||||
logger.info(f"✅ System saved:")
|
||||
logger.info(f" 📄 Global contexts: {global_file}")
|
||||
logger.info(f" ⚙️ Configuration: {config_file}")
|
||||
logger.info(f" 🕸️ Temporal data: {self.temporal_graph.temporal_dir}")
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Bounded Hierarchical Context System Demo")
|
||||
parser.add_argument("--project-path", default="/tmp/demo-bzzz-cascading",
|
||||
help="Path to project directory")
|
||||
parser.add_argument("--metadata-base", default="/tmp/bounded-context-metadata",
|
||||
help="Base directory for metadata storage")
|
||||
parser.add_argument("--max-depth", type=int, default=8,
|
||||
help="Maximum hierarchy depth for bounded walking")
|
||||
parser.add_argument("--decision-hops", type=int, default=3,
|
||||
help="Maximum decision hops for temporal analysis")
|
||||
parser.add_argument("--demo-global", action="store_true",
|
||||
help="Demonstrate global context functionality")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
logger.info("🎬 Bounded Hierarchical Context System Demo")
|
||||
logger.info("=" * 50)
|
||||
|
||||
# Initialize the bounded system
|
||||
bounded_system = BoundedContextSystem(
|
||||
args.project_path,
|
||||
args.metadata_base,
|
||||
args.max_depth
|
||||
)
|
||||
|
||||
bounded_system.initialize_system()
|
||||
|
||||
# Generate hierarchical metadata
|
||||
results = bounded_system.generate_hierarchical_metadata()
|
||||
|
||||
# Setup global contexts if requested
|
||||
if args.demo_global:
|
||||
bounded_system.setup_global_contexts()
|
||||
|
||||
# Demonstrate bounded resolution
|
||||
bounded_system.demonstrate_bounded_resolution()
|
||||
|
||||
# Demonstrate decision-hop analysis
|
||||
bounded_system.demonstrate_decision_hop_analysis(args.decision_hops)
|
||||
|
||||
# Save the system
|
||||
bounded_system.save_bounded_system()
|
||||
|
||||
logger.info("\n✨ Demo Complete!")
|
||||
logger.info("=" * 20)
|
||||
logger.info("🎉 Bounded hierarchical context system demonstrated successfully")
|
||||
logger.info("📏 Hierarchy walking bounded to prevent excessive traversal")
|
||||
logger.info("🌐 Global contexts provide system-wide applicable metadata")
|
||||
logger.info("🕸️ Decision-hop analysis tracks conceptually related changes")
|
||||
logger.info("💾 Space-efficient storage through intelligent inheritance")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
672
slurp/context-intelligence/cascading_metadata_generator.py
Normal file
672
slurp/context-intelligence/cascading_metadata_generator.py
Normal file
@@ -0,0 +1,672 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Cascading Hierarchical Metadata Generator
|
||||
|
||||
This system implements CSS-like cascading for contextual metadata:
|
||||
|
||||
1. Context flows DOWN the directory tree (inheritance)
|
||||
2. More specific contexts override parent contexts
|
||||
3. Only unique/different metadata is stored per level
|
||||
4. Lookups resolve by walking UP the tree to find applicable context
|
||||
5. Massive space savings by avoiding redundant metadata
|
||||
|
||||
Key Concepts:
|
||||
- Context Inheritance: Child directories inherit parent context unless overridden
|
||||
- Context Specificity: More specific paths can override parent context
|
||||
- Context Consolidation: Similar contexts are merged/consolidated
|
||||
- Lazy Resolution: Context is resolved at query time by walking the hierarchy
|
||||
|
||||
Usage:
|
||||
python3 cascading_metadata_generator.py [--bzzz-path PATH] [--rag-endpoint URL]
|
||||
"""
|
||||
|
||||
import os
|
||||
import json
|
||||
import argparse
|
||||
import hashlib
|
||||
from pathlib import Path
|
||||
from typing import Dict, List, Optional, Any, Set, Tuple
|
||||
from datetime import datetime, timezone
|
||||
from dataclasses import dataclass, asdict
|
||||
import requests
|
||||
import logging
|
||||
from collections import defaultdict
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@dataclass
|
||||
class ContextNode:
|
||||
"""Represents a context node in the hierarchical tree"""
|
||||
path: str
|
||||
ucxl_address: str
|
||||
summary: str
|
||||
purpose: str
|
||||
technologies: List[str]
|
||||
tags: List[str]
|
||||
insights: List[str]
|
||||
overrides_parent: bool = False # Does this context override parent?
|
||||
context_specificity: int = 0 # Higher = more specific
|
||||
applies_to_children: bool = True # Does this context cascade down?
|
||||
generated_at: str = ""
|
||||
rag_confidence: float = 0.0
|
||||
|
||||
@dataclass
|
||||
class PathMetadata:
|
||||
"""Lightweight path metadata - most context comes from hierarchy"""
|
||||
ucxl_address: str
|
||||
filesystem_path: str
|
||||
file_type: str
|
||||
size_bytes: Optional[int]
|
||||
extension: Optional[str]
|
||||
language: Optional[str]
|
||||
content_hash: Optional[str]
|
||||
last_modified: Optional[str]
|
||||
has_local_context: bool = False # Does this path have its own context node?
|
||||
|
||||
class CascadingMetadataSystem:
|
||||
def __init__(self, bzzz_path: str, rag_endpoint: str, metadata_base: str):
|
||||
self.bzzz_path = Path(bzzz_path)
|
||||
self.rag_endpoint = rag_endpoint
|
||||
self.metadata_base = Path(metadata_base)
|
||||
self.project_name = "BZZZ"
|
||||
self.project_metadata_dir = self.metadata_base / self.project_name
|
||||
|
||||
# Context hierarchy storage
|
||||
self.context_tree: Dict[str, ContextNode] = {}
|
||||
self.path_metadata: Dict[str, PathMetadata] = {}
|
||||
|
||||
# Context consolidation data
|
||||
self.context_patterns = defaultdict(list) # Similar contexts grouped
|
||||
self.directory_purposes = {} # Common directory purposes
|
||||
|
||||
# Ensure metadata directory exists
|
||||
self.project_metadata_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
def analyze_directory_structure(self) -> Dict[str, Any]:
|
||||
"""Analyze the entire directory structure to identify patterns and hierarchy"""
|
||||
logger.info("🔍 Analyzing directory structure for context patterns...")
|
||||
|
||||
directory_analysis = {
|
||||
'common_purposes': defaultdict(list),
|
||||
'technology_clusters': defaultdict(set),
|
||||
'pattern_directories': defaultdict(list),
|
||||
'depth_analysis': defaultdict(int)
|
||||
}
|
||||
|
||||
for item in self.bzzz_path.rglob('*'):
|
||||
if not self.should_process_path(item):
|
||||
continue
|
||||
|
||||
rel_path = item.relative_to(self.bzzz_path)
|
||||
depth = len(rel_path.parts)
|
||||
directory_analysis['depth_analysis'][depth] += 1
|
||||
|
||||
# Analyze directory patterns
|
||||
if item.is_dir():
|
||||
dir_name = item.name.lower()
|
||||
|
||||
# Common directory patterns
|
||||
if dir_name in ['src', 'source', 'lib']:
|
||||
directory_analysis['common_purposes']['source_code'].append(str(rel_path))
|
||||
elif dir_name in ['test', 'tests', 'spec', 'specs']:
|
||||
directory_analysis['common_purposes']['testing'].append(str(rel_path))
|
||||
elif dir_name in ['doc', 'docs', 'documentation']:
|
||||
directory_analysis['common_purposes']['documentation'].append(str(rel_path))
|
||||
elif dir_name in ['config', 'configuration', 'settings']:
|
||||
directory_analysis['common_purposes']['configuration'].append(str(rel_path))
|
||||
elif dir_name in ['asset', 'assets', 'static', 'public']:
|
||||
directory_analysis['common_purposes']['assets'].append(str(rel_path))
|
||||
elif dir_name in ['font', 'fonts']:
|
||||
directory_analysis['common_purposes']['fonts'].append(str(rel_path))
|
||||
elif dir_name in ['image', 'images', 'img']:
|
||||
directory_analysis['common_purposes']['images'].append(str(rel_path))
|
||||
elif dir_name in ['style', 'styles', 'css']:
|
||||
directory_analysis['common_purposes']['styling'].append(str(rel_path))
|
||||
elif dir_name in ['script', 'scripts', 'js']:
|
||||
directory_analysis['common_purposes']['scripts'].append(str(rel_path))
|
||||
elif dir_name in ['build', 'dist', 'output', 'target']:
|
||||
directory_analysis['common_purposes']['build_output'].append(str(rel_path))
|
||||
elif dir_name in ['vendor', 'third_party', 'external']:
|
||||
directory_analysis['common_purposes']['third_party'].append(str(rel_path))
|
||||
elif dir_name in ['util', 'utils', 'helper', 'helpers', 'common']:
|
||||
directory_analysis['common_purposes']['utilities'].append(str(rel_path))
|
||||
elif dir_name in ['api', 'endpoint', 'service', 'services']:
|
||||
directory_analysis['common_purposes']['api_services'].append(str(rel_path))
|
||||
elif dir_name in ['model', 'models', 'entity', 'entities']:
|
||||
directory_analysis['common_purposes']['data_models'].append(str(rel_path))
|
||||
elif dir_name in ['component', 'components', 'widget', 'widgets']:
|
||||
directory_analysis['common_purposes']['ui_components'].append(str(rel_path))
|
||||
elif dir_name in ['template', 'templates', 'layout', 'layouts']:
|
||||
directory_analysis['common_purposes']['templates'].append(str(rel_path))
|
||||
|
||||
# Analyze technology clusters by file extensions
|
||||
if item.is_file():
|
||||
ext = item.suffix.lower()
|
||||
parent_dir = str(rel_path.parent) if rel_path.parent != Path('.') else 'root'
|
||||
directory_analysis['technology_clusters'][parent_dir].add(ext)
|
||||
|
||||
logger.info(f"📊 Found {len(directory_analysis['common_purposes'])} common directory patterns")
|
||||
logger.info(f"🔧 Identified {len(directory_analysis['technology_clusters'])} technology clusters")
|
||||
|
||||
return directory_analysis
|
||||
|
||||
def create_context_hierarchy(self) -> None:
|
||||
"""Create the cascading context hierarchy based on directory analysis"""
|
||||
logger.info("🏗️ Building cascading context hierarchy...")
|
||||
|
||||
# First, analyze the structure
|
||||
structure_analysis = self.analyze_directory_structure()
|
||||
|
||||
# Create context nodes for significant directories
|
||||
contexts_created = 0
|
||||
|
||||
for purpose, directories in structure_analysis['common_purposes'].items():
|
||||
for dir_path in directories:
|
||||
full_path = self.bzzz_path / dir_path
|
||||
if full_path.exists() and full_path.is_dir():
|
||||
context_node = self.create_directory_context(full_path, purpose)
|
||||
if context_node:
|
||||
self.context_tree[str(full_path)] = context_node
|
||||
contexts_created += 1
|
||||
|
||||
# Create root project context
|
||||
root_context = self.create_root_context()
|
||||
self.context_tree[str(self.bzzz_path)] = root_context
|
||||
contexts_created += 1
|
||||
|
||||
logger.info(f"✅ Created {contexts_created} context nodes in hierarchy")
|
||||
|
||||
def create_root_context(self) -> ContextNode:
|
||||
"""Create the root context for the entire project"""
|
||||
return ContextNode(
|
||||
path=str(self.bzzz_path),
|
||||
ucxl_address="ucxl://any:any@BZZZ:RUSTLE-testing",
|
||||
summary="BZZZ distributed system project root",
|
||||
purpose="Core distributed system implementing contextual metadata architecture with 1:1 filesystem mapping",
|
||||
technologies=["Rust", "Go", "Distributed Systems", "P2P", "DHT", "UCXL Protocol"],
|
||||
tags=["project-root", "distributed-system", "bzzz", "ucxl", "rust", "go"],
|
||||
insights=[
|
||||
"Main project implementing distributed contextual metadata system",
|
||||
"Uses UCXL protocol for unified contextual exchange",
|
||||
"Implements 1:1 mapping between filesystem and UCXL addresses",
|
||||
"Part of larger CHORUS ecosystem for AI development"
|
||||
],
|
||||
overrides_parent=False,
|
||||
context_specificity=0,
|
||||
applies_to_children=True,
|
||||
generated_at=datetime.now(timezone.utc).isoformat(),
|
||||
rag_confidence=0.9
|
||||
)
|
||||
|
||||
def create_directory_context(self, dir_path: Path, purpose_type: str) -> Optional[ContextNode]:
|
||||
"""Create context for a specific directory based on its purpose"""
|
||||
|
||||
rel_path = dir_path.relative_to(self.bzzz_path)
|
||||
ucxl_address = f"ucxl://any:any@BZZZ:RUSTLE-testing/{str(rel_path).replace(os.sep, '/')}"
|
||||
|
||||
# Context templates based on directory purpose
|
||||
context_templates = {
|
||||
'source_code': {
|
||||
'summary': f"Source code directory: {dir_path.name}",
|
||||
'purpose': "Implementation of core system functionality and business logic",
|
||||
'technologies': ["Rust", "Go", "Source Code"],
|
||||
'tags': ["source-code", "implementation", "core-logic"],
|
||||
'insights': [
|
||||
"Contains primary implementation files",
|
||||
"Houses main business logic and algorithms",
|
||||
"Critical for system functionality"
|
||||
]
|
||||
},
|
||||
'testing': {
|
||||
'summary': f"Testing directory: {dir_path.name}",
|
||||
'purpose': "Quality assurance, validation, and testing infrastructure",
|
||||
'technologies': ["Testing Frameworks", "Unit Tests", "Integration Tests"],
|
||||
'tags': ["testing", "qa", "validation", "quality-assurance"],
|
||||
'insights': [
|
||||
"Ensures code quality and correctness",
|
||||
"Provides regression testing capabilities",
|
||||
"Critical for maintaining system reliability"
|
||||
]
|
||||
},
|
||||
'documentation': {
|
||||
'summary': f"Documentation directory: {dir_path.name}",
|
||||
'purpose': "Project documentation, guides, and knowledge resources",
|
||||
'technologies': ["Markdown", "Documentation"],
|
||||
'tags': ["documentation", "guides", "knowledge", "reference"],
|
||||
'insights': [
|
||||
"Provides user and developer guidance",
|
||||
"Contains architectural decisions and design docs",
|
||||
"Essential for project maintainability"
|
||||
]
|
||||
},
|
||||
'configuration': {
|
||||
'summary': f"Configuration directory: {dir_path.name}",
|
||||
'purpose': "System configuration, settings, and environment management",
|
||||
'technologies': ["TOML", "YAML", "JSON", "Configuration"],
|
||||
'tags': ["configuration", "settings", "environment", "deployment"],
|
||||
'insights': [
|
||||
"Manages system behavior and parameters",
|
||||
"Controls deployment and runtime settings",
|
||||
"Centralizes configuration management"
|
||||
]
|
||||
},
|
||||
'assets': {
|
||||
'summary': f"Assets directory: {dir_path.name}",
|
||||
'purpose': "Static assets, resources, and multimedia content",
|
||||
'technologies': ["Static Assets", "Resources"],
|
||||
'tags': ["assets", "resources", "static", "content"],
|
||||
'insights': [
|
||||
"Houses non-code project resources",
|
||||
"Supports user interface and experience",
|
||||
"Manages static content delivery"
|
||||
]
|
||||
},
|
||||
'fonts': {
|
||||
'summary': f"Fonts directory: {dir_path.name}",
|
||||
'purpose': "Typography assets implementing design system specifications",
|
||||
'technologies': ["Typography", "Fonts", "Design System"],
|
||||
'tags': ["fonts", "typography", "design-system", "ui"],
|
||||
'insights': [
|
||||
"Implements brand typography guidelines",
|
||||
"Ensures consistent visual identity",
|
||||
"Supports responsive design requirements"
|
||||
]
|
||||
},
|
||||
'api_services': {
|
||||
'summary': f"API services directory: {dir_path.name}",
|
||||
'purpose': "API endpoints, service interfaces, and external communication",
|
||||
'technologies': ["REST API", "HTTP", "Service Layer"],
|
||||
'tags': ["api", "services", "endpoints", "communication"],
|
||||
'insights': [
|
||||
"Defines external system interfaces",
|
||||
"Handles inter-service communication",
|
||||
"Critical for system integration"
|
||||
]
|
||||
},
|
||||
'utilities': {
|
||||
'summary': f"Utilities directory: {dir_path.name}",
|
||||
'purpose': "Shared utilities, helpers, and common functionality",
|
||||
'technologies': ["Utilities", "Helper Functions", "Common Code"],
|
||||
'tags': ["utilities", "helpers", "shared", "common"],
|
||||
'insights': [
|
||||
"Provides reusable functionality",
|
||||
"Reduces code duplication",
|
||||
"Supports DRY principles"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
if purpose_type not in context_templates:
|
||||
return None
|
||||
|
||||
template = context_templates[purpose_type]
|
||||
|
||||
return ContextNode(
|
||||
path=str(dir_path),
|
||||
ucxl_address=ucxl_address,
|
||||
summary=template['summary'],
|
||||
purpose=template['purpose'],
|
||||
technologies=template['technologies'],
|
||||
tags=template['tags'],
|
||||
insights=template['insights'],
|
||||
overrides_parent=False,
|
||||
context_specificity=len(rel_path.parts),
|
||||
applies_to_children=True,
|
||||
generated_at=datetime.now(timezone.utc).isoformat(),
|
||||
rag_confidence=0.8
|
||||
)
|
||||
|
||||
def resolve_context_for_path(self, file_path: Path) -> ContextNode:
|
||||
"""Resolve context for a path by walking UP the hierarchy (CSS-like cascading)"""
|
||||
|
||||
# Start from the file's directory and walk up to find applicable context
|
||||
current_path = file_path if file_path.is_dir() else file_path.parent
|
||||
|
||||
contexts = []
|
||||
|
||||
# Walk up the directory tree collecting contexts
|
||||
while current_path >= self.bzzz_path:
|
||||
if str(current_path) in self.context_tree:
|
||||
context = self.context_tree[str(current_path)]
|
||||
if context.applies_to_children:
|
||||
contexts.append(context)
|
||||
if context.overrides_parent:
|
||||
break
|
||||
current_path = current_path.parent
|
||||
|
||||
# If no contexts found, use root context
|
||||
if not contexts:
|
||||
return self.context_tree.get(str(self.bzzz_path), self.create_root_context())
|
||||
|
||||
# Merge contexts (more specific overrides less specific)
|
||||
return self.merge_contexts(contexts, file_path)
|
||||
|
||||
def merge_contexts(self, contexts: List[ContextNode], file_path: Path) -> ContextNode:
|
||||
"""Merge multiple contexts using CSS-like specificity rules"""
|
||||
|
||||
if len(contexts) == 1:
|
||||
return contexts[0]
|
||||
|
||||
# Sort by specificity (higher = more specific)
|
||||
contexts.sort(key=lambda c: c.context_specificity, reverse=True)
|
||||
|
||||
# Start with most specific context
|
||||
merged = contexts[0]
|
||||
|
||||
# Merge in less specific contexts where not overridden
|
||||
for context in contexts[1:]:
|
||||
# Tags are additive (union)
|
||||
merged.tags = list(set(merged.tags + context.tags))
|
||||
|
||||
# Technologies are additive (union)
|
||||
merged.technologies = list(set(merged.technologies + context.technologies))
|
||||
|
||||
# Insights are additive (append unique)
|
||||
for insight in context.insights:
|
||||
if insight not in merged.insights:
|
||||
merged.insights.append(insight)
|
||||
|
||||
# Summary and purpose use most specific unless empty
|
||||
if not merged.summary:
|
||||
merged.summary = context.summary
|
||||
if not merged.purpose:
|
||||
merged.purpose = context.purpose
|
||||
|
||||
# Update path-specific information
|
||||
rel_path = file_path.relative_to(self.bzzz_path)
|
||||
merged.ucxl_address = f"ucxl://any:any@BZZZ:RUSTLE-testing/{str(rel_path).replace(os.sep, '/')}"
|
||||
merged.path = str(file_path)
|
||||
|
||||
return merged
|
||||
|
||||
def should_process_path(self, path: Path) -> bool:
|
||||
"""Determine if a path should be processed"""
|
||||
if any(part.startswith('.') for part in path.parts):
|
||||
return False
|
||||
|
||||
ignore_patterns = [
|
||||
'target/', 'node_modules/', '__pycache__/', '.git/',
|
||||
'vendor/', 'build/', 'dist/', '.cache/', 'tmp/'
|
||||
]
|
||||
|
||||
path_str = str(path).lower()
|
||||
return not any(pattern in path_str for pattern in ignore_patterns)
|
||||
|
||||
def create_path_metadata(self, file_path: Path) -> PathMetadata:
|
||||
"""Create lightweight metadata for a path (context comes from hierarchy)"""
|
||||
|
||||
is_dir = file_path.is_dir()
|
||||
rel_path = file_path.relative_to(self.bzzz_path)
|
||||
ucxl_address = f"ucxl://any:any@BZZZ:RUSTLE-testing/{str(rel_path).replace(os.sep, '/')}"
|
||||
|
||||
# Basic file information only
|
||||
size_bytes = None
|
||||
content_hash = None
|
||||
last_modified = None
|
||||
|
||||
if not is_dir:
|
||||
try:
|
||||
stat = file_path.stat()
|
||||
size_bytes = stat.st_size
|
||||
last_modified = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat()
|
||||
|
||||
# Only hash small text files
|
||||
if size_bytes < 50000: # 50KB limit
|
||||
try:
|
||||
content = file_path.read_text(encoding='utf-8')
|
||||
content_hash = hashlib.sha256(content.encode('utf-8')).hexdigest()
|
||||
except:
|
||||
pass
|
||||
except:
|
||||
pass
|
||||
|
||||
# Determine language/type
|
||||
language = None
|
||||
if not is_dir:
|
||||
ext = file_path.suffix.lower()
|
||||
lang_map = {
|
||||
'.rs': 'rust', '.go': 'go', '.py': 'python',
|
||||
'.js': 'javascript', '.ts': 'typescript', '.md': 'markdown',
|
||||
'.toml': 'toml', '.yaml': 'yaml', '.yml': 'yaml', '.json': 'json'
|
||||
}
|
||||
language = lang_map.get(ext)
|
||||
|
||||
return PathMetadata(
|
||||
ucxl_address=ucxl_address,
|
||||
filesystem_path=str(file_path),
|
||||
file_type="directory" if is_dir else "file",
|
||||
size_bytes=size_bytes,
|
||||
extension=file_path.suffix if not is_dir else None,
|
||||
language=language,
|
||||
content_hash=content_hash,
|
||||
last_modified=last_modified,
|
||||
has_local_context=str(file_path) in self.context_tree
|
||||
)
|
||||
|
||||
def save_cascading_metadata(self) -> Dict[str, Any]:
|
||||
"""Save the cascading metadata system to files"""
|
||||
|
||||
# Save context hierarchy
|
||||
hierarchy_file = self.project_metadata_dir / "context_hierarchy.json"
|
||||
hierarchy_data = {
|
||||
path: asdict(context) for path, context in self.context_tree.items()
|
||||
}
|
||||
|
||||
with open(hierarchy_file, 'w', encoding='utf-8') as f:
|
||||
json.dump(hierarchy_data, f, indent=2, ensure_ascii=False)
|
||||
|
||||
# Save path metadata (lightweight)
|
||||
paths_file = self.project_metadata_dir / "path_metadata.json"
|
||||
paths_data = {
|
||||
path: asdict(metadata) for path, metadata in self.path_metadata.items()
|
||||
}
|
||||
|
||||
with open(paths_file, 'w', encoding='utf-8') as f:
|
||||
json.dump(paths_data, f, indent=2, ensure_ascii=False)
|
||||
|
||||
# Generate lookup index for fast context resolution
|
||||
lookup_index = {}
|
||||
for path, metadata in self.path_metadata.items():
|
||||
file_path = Path(path)
|
||||
resolved_context = self.resolve_context_for_path(file_path)
|
||||
lookup_index[metadata.ucxl_address] = {
|
||||
'context_path': resolved_context.path,
|
||||
'specificity': resolved_context.context_specificity,
|
||||
'has_local_context': metadata.has_local_context
|
||||
}
|
||||
|
||||
index_file = self.project_metadata_dir / "context_lookup_index.json"
|
||||
with open(index_file, 'w', encoding='utf-8') as f:
|
||||
json.dump(lookup_index, f, indent=2, ensure_ascii=False)
|
||||
|
||||
return {
|
||||
'context_nodes': len(self.context_tree),
|
||||
'path_entries': len(self.path_metadata),
|
||||
'hierarchy_file': str(hierarchy_file),
|
||||
'paths_file': str(paths_file),
|
||||
'index_file': str(index_file)
|
||||
}
|
||||
|
||||
def generate_context_demo(self, demo_paths: List[str]) -> Dict[str, Any]:
|
||||
"""Generate a demo showing how context cascades for specific paths"""
|
||||
|
||||
demo_results = {}
|
||||
|
||||
for path_str in demo_paths:
|
||||
file_path = Path(path_str)
|
||||
if not file_path.exists():
|
||||
continue
|
||||
|
||||
resolved_context = self.resolve_context_for_path(file_path)
|
||||
path_metadata = self.path_metadata.get(str(file_path), {})
|
||||
|
||||
demo_results[path_str] = {
|
||||
'ucxl_address': resolved_context.ucxl_address,
|
||||
'resolved_context': {
|
||||
'summary': resolved_context.summary,
|
||||
'purpose': resolved_context.purpose,
|
||||
'technologies': resolved_context.technologies,
|
||||
'tags': resolved_context.tags,
|
||||
'context_source': resolved_context.path,
|
||||
'specificity': resolved_context.context_specificity
|
||||
},
|
||||
'path_metadata': asdict(path_metadata) if hasattr(path_metadata, '__dict__') else path_metadata,
|
||||
'inheritance_chain': self.get_inheritance_chain(file_path)
|
||||
}
|
||||
|
||||
return demo_results
|
||||
|
||||
def get_inheritance_chain(self, file_path: Path) -> List[str]:
|
||||
"""Get the chain of context inheritance for a path"""
|
||||
chain = []
|
||||
current_path = file_path if file_path.is_dir() else file_path.parent
|
||||
|
||||
while current_path >= self.bzzz_path:
|
||||
if str(current_path) in self.context_tree:
|
||||
chain.append(str(current_path))
|
||||
current_path = current_path.parent
|
||||
|
||||
return chain
|
||||
|
||||
def process_repository(self) -> Dict[str, Any]:
|
||||
"""Process the entire repository with cascading context system"""
|
||||
logger.info("🚀 Processing repository with cascading context system...")
|
||||
|
||||
# Step 1: Create context hierarchy
|
||||
self.create_context_hierarchy()
|
||||
|
||||
# Step 2: Create lightweight metadata for all paths
|
||||
paths_processed = 0
|
||||
for item in self.bzzz_path.rglob('*'):
|
||||
if not self.should_process_path(item):
|
||||
continue
|
||||
|
||||
metadata = self.create_path_metadata(item)
|
||||
self.path_metadata[str(item)] = metadata
|
||||
paths_processed += 1
|
||||
|
||||
logger.info(f"📊 Processed {paths_processed} paths with {len(self.context_tree)} context nodes")
|
||||
|
||||
# Step 3: Save the system
|
||||
save_results = self.save_cascading_metadata()
|
||||
|
||||
# Step 4: Calculate space savings
|
||||
traditional_size = paths_processed * 2000 # Estimate 2KB per traditional metadata file
|
||||
actual_size = len(self.context_tree) * 2000 + paths_processed * 500 # Context + lightweight metadata
|
||||
space_savings = ((traditional_size - actual_size) / traditional_size) * 100
|
||||
|
||||
return {
|
||||
'paths_processed': paths_processed,
|
||||
'context_nodes': len(self.context_tree),
|
||||
'space_savings_percent': space_savings,
|
||||
'estimated_traditional_size_kb': traditional_size // 1024,
|
||||
'actual_size_kb': actual_size // 1024,
|
||||
**save_results
|
||||
}
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Generate cascading hierarchical metadata for BZZZ project")
|
||||
parser.add_argument("--bzzz-path", default="/home/tony/chorus/project-queues/active/BZZZ",
|
||||
help="Path to BZZZ repository")
|
||||
parser.add_argument("--metadata-base", default=os.path.expanduser("~/chorus/project-metadata"),
|
||||
help="Base directory for metadata storage")
|
||||
parser.add_argument("--demo", action="store_true",
|
||||
help="Run demonstration with sample paths")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Check if BZZZ path exists, create demo if not
|
||||
bzzz_path = Path(args.bzzz_path)
|
||||
if not bzzz_path.exists():
|
||||
logger.warning(f"BZZZ repository not found at: {bzzz_path}")
|
||||
logger.info("Creating demo structure...")
|
||||
|
||||
demo_path = Path("/tmp/demo-bzzz-cascading")
|
||||
demo_path.mkdir(exist_ok=True)
|
||||
|
||||
# Create comprehensive demo structure
|
||||
directories = [
|
||||
"src", "src/api", "src/core", "src/utils",
|
||||
"tests", "tests/unit", "tests/integration",
|
||||
"docs", "docs/api", "docs/user",
|
||||
"config", "config/dev", "config/prod",
|
||||
"assets", "assets/fonts", "assets/images",
|
||||
"scripts", "build"
|
||||
]
|
||||
|
||||
for dir_path in directories:
|
||||
(demo_path / dir_path).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Create demo files
|
||||
files = {
|
||||
"README.md": "# BZZZ Project\n\nDistributed contextual metadata system",
|
||||
"Cargo.toml": "[package]\nname = \"bzzz\"\nversion = \"0.1.0\"",
|
||||
"src/main.rs": "fn main() { println!(\"BZZZ!\"); }",
|
||||
"src/lib.rs": "//! BZZZ core library",
|
||||
"src/api/handlers.rs": "//! HTTP request handlers",
|
||||
"src/core/engine.rs": "//! Core processing engine",
|
||||
"src/utils/helpers.rs": "//! Utility functions",
|
||||
"tests/unit/core_tests.rs": "//! Unit tests for core",
|
||||
"tests/integration/api_tests.rs": "//! API integration tests",
|
||||
"docs/README.md": "# Documentation\n\nProject documentation",
|
||||
"docs/api/endpoints.md": "# API Endpoints",
|
||||
"config/settings.toml": "[server]\nport = 8080",
|
||||
"assets/fonts/README.md": "# Fonts\n\nTypography assets for UI",
|
||||
"scripts/build.sh": "#!/bin/bash\ncargo build --release"
|
||||
}
|
||||
|
||||
for file_path, content in files.items():
|
||||
full_path = demo_path / file_path
|
||||
full_path.write_text(content)
|
||||
|
||||
bzzz_path = demo_path
|
||||
logger.info(f"Demo structure created at: {demo_path}")
|
||||
|
||||
# Initialize the cascading system
|
||||
system = CascadingMetadataSystem(
|
||||
bzzz_path=str(bzzz_path),
|
||||
rag_endpoint="http://localhost:8000/query", # Not used in this version
|
||||
metadata_base=args.metadata_base
|
||||
)
|
||||
|
||||
# Process the repository
|
||||
results = system.process_repository()
|
||||
|
||||
logger.info("✅ Cascading metadata system complete!")
|
||||
logger.info(f"📊 Results:")
|
||||
logger.info(f" 📁 Paths processed: {results['paths_processed']}")
|
||||
logger.info(f" 🏗️ Context nodes: {results['context_nodes']}")
|
||||
logger.info(f" 💾 Space savings: {results['space_savings_percent']:.1f}%")
|
||||
logger.info(f" 📏 Traditional size: {results['estimated_traditional_size_kb']} KB")
|
||||
logger.info(f" 🎯 Actual size: {results['actual_size_kb']} KB")
|
||||
logger.info(f" 📂 Files saved:")
|
||||
logger.info(f" 🏗️ Hierarchy: {results['hierarchy_file']}")
|
||||
logger.info(f" 📄 Paths: {results['paths_file']}")
|
||||
logger.info(f" 🔍 Index: {results['index_file']}")
|
||||
|
||||
# Run demo if requested
|
||||
if args.demo:
|
||||
logger.info("\n🎬 Running context resolution demo...")
|
||||
|
||||
demo_paths = [
|
||||
str(bzzz_path / "src" / "main.rs"),
|
||||
str(bzzz_path / "src" / "api" / "handlers.rs"),
|
||||
str(bzzz_path / "tests" / "unit" / "core_tests.rs"),
|
||||
str(bzzz_path / "assets" / "fonts" / "README.md"),
|
||||
str(bzzz_path / "config" / "settings.toml")
|
||||
]
|
||||
|
||||
demo_results = system.generate_context_demo(demo_paths)
|
||||
|
||||
for path, info in demo_results.items():
|
||||
logger.info(f"\n📄 {path}:")
|
||||
logger.info(f" 🔗 UCXL: {info['ucxl_address']}")
|
||||
logger.info(f" 📝 Summary: {info['resolved_context']['summary']}")
|
||||
logger.info(f" 🎯 Purpose: {info['resolved_context']['purpose']}")
|
||||
logger.info(f" 🏷️ Tags: {', '.join(info['resolved_context']['tags'][:5])}")
|
||||
logger.info(f" 📊 Context from: {Path(info['resolved_context']['context_source']).name}")
|
||||
logger.info(f" 🔗 Inheritance: {' → '.join([Path(p).name for p in info['inheritance_chain']])}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
438
slurp/context-intelligence/context_resolver.py
Normal file
438
slurp/context-intelligence/context_resolver.py
Normal file
@@ -0,0 +1,438 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Cascading Context Resolution System
|
||||
|
||||
This system efficiently resolves context for UCXL addresses by:
|
||||
1. Loading the cascading metadata hierarchy
|
||||
2. Resolving context through CSS-like inheritance
|
||||
3. Providing fast lookups with caching
|
||||
4. Supporting temporal context evolution (decisions change over time)
|
||||
|
||||
The temporal component you mentioned is crucial - we need to track how context
|
||||
and decisions evolve over time. A temporal graph network could indeed be the
|
||||
way to handle this, where each context node has temporal versions.
|
||||
|
||||
Usage:
|
||||
from context_resolver import CascadingContextResolver
|
||||
|
||||
resolver = CascadingContextResolver("~/chorus/project-metadata/BZZZ")
|
||||
context = resolver.resolve("ucxl://any:any@BZZZ:RUSTLE-testing/src/main.rs")
|
||||
"""
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Dict, List, Optional, Any, Tuple
|
||||
from datetime import datetime, timezone
|
||||
from dataclasses import dataclass
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@dataclass
|
||||
class ResolvedContext:
|
||||
"""Complete resolved context for a UCXL address"""
|
||||
ucxl_address: str
|
||||
summary: str
|
||||
purpose: str
|
||||
technologies: List[str]
|
||||
tags: List[str]
|
||||
insights: List[str]
|
||||
|
||||
# Metadata
|
||||
file_type: str
|
||||
size_bytes: Optional[int]
|
||||
language: Optional[str]
|
||||
last_modified: Optional[str]
|
||||
content_hash: Optional[str]
|
||||
|
||||
# Resolution metadata
|
||||
context_source_path: str
|
||||
inheritance_chain: List[str]
|
||||
resolution_confidence: float
|
||||
resolved_at: str
|
||||
|
||||
# Temporal metadata (for future enhancement)
|
||||
temporal_version: int = 1
|
||||
context_evolution: List[str] = None
|
||||
|
||||
class CascadingContextResolver:
|
||||
"""Efficiently resolves cascading context for UCXL addresses"""
|
||||
|
||||
def __init__(self, metadata_dir: str, max_hierarchy_depth: int = 10):
|
||||
self.metadata_dir = Path(metadata_dir)
|
||||
self.context_hierarchy = {}
|
||||
self.path_metadata = {}
|
||||
self.lookup_index = {}
|
||||
self.resolution_cache = {}
|
||||
self.global_contexts = [] # Contexts that apply to all paths
|
||||
self.max_hierarchy_depth = max_hierarchy_depth
|
||||
|
||||
self.load_metadata_system()
|
||||
|
||||
def load_metadata_system(self) -> None:
|
||||
"""Load the cascading metadata system from files"""
|
||||
|
||||
try:
|
||||
# Load context hierarchy
|
||||
hierarchy_file = self.metadata_dir / "context_hierarchy.json"
|
||||
if hierarchy_file.exists():
|
||||
with open(hierarchy_file, 'r') as f:
|
||||
self.context_hierarchy = json.load(f)
|
||||
logger.info(f"Loaded {len(self.context_hierarchy)} context nodes")
|
||||
|
||||
# Load path metadata
|
||||
paths_file = self.metadata_dir / "path_metadata.json"
|
||||
if paths_file.exists():
|
||||
with open(paths_file, 'r') as f:
|
||||
self.path_metadata = json.load(f)
|
||||
logger.info(f"Loaded {len(self.path_metadata)} path entries")
|
||||
|
||||
# Load lookup index
|
||||
index_file = self.metadata_dir / "context_lookup_index.json"
|
||||
if index_file.exists():
|
||||
with open(index_file, 'r') as f:
|
||||
self.lookup_index = json.load(f)
|
||||
logger.info(f"Loaded {len(self.lookup_index)} lookup entries")
|
||||
|
||||
# Load global contexts
|
||||
global_file = self.metadata_dir / "global_contexts.json"
|
||||
if global_file.exists():
|
||||
with open(global_file, 'r') as f:
|
||||
self.global_contexts = json.load(f)
|
||||
logger.info(f"Loaded {len(self.global_contexts)} global contexts")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error loading metadata system: {e}")
|
||||
raise
|
||||
|
||||
def resolve(self, ucxl_address: str) -> Optional[ResolvedContext]:
|
||||
"""Resolve context for a UCXL address using cascading inheritance"""
|
||||
|
||||
# Check cache first
|
||||
if ucxl_address in self.resolution_cache:
|
||||
return self.resolution_cache[ucxl_address]
|
||||
|
||||
# Find the filesystem path from UCXL address
|
||||
filesystem_path = self.ucxl_to_filesystem_path(ucxl_address)
|
||||
if not filesystem_path:
|
||||
return None
|
||||
|
||||
# Get path metadata
|
||||
path_meta = self.path_metadata.get(filesystem_path)
|
||||
if not path_meta:
|
||||
return None
|
||||
|
||||
# Resolve context through hierarchy with bounded traversal
|
||||
resolved_context = self.resolve_cascading_context(filesystem_path, self.max_hierarchy_depth)
|
||||
if not resolved_context:
|
||||
return None
|
||||
|
||||
# Combine path metadata with resolved context
|
||||
result = ResolvedContext(
|
||||
ucxl_address=ucxl_address,
|
||||
summary=resolved_context.get('summary', ''),
|
||||
purpose=resolved_context.get('purpose', ''),
|
||||
technologies=resolved_context.get('technologies', []),
|
||||
tags=resolved_context.get('tags', []),
|
||||
insights=resolved_context.get('insights', []),
|
||||
|
||||
file_type=path_meta.get('file_type', 'unknown'),
|
||||
size_bytes=path_meta.get('size_bytes'),
|
||||
language=path_meta.get('language'),
|
||||
last_modified=path_meta.get('last_modified'),
|
||||
content_hash=path_meta.get('content_hash'),
|
||||
|
||||
context_source_path=resolved_context.get('source_path', ''),
|
||||
inheritance_chain=resolved_context.get('inheritance_chain', []),
|
||||
resolution_confidence=resolved_context.get('confidence', 0.5),
|
||||
resolved_at=datetime.now(timezone.utc).isoformat(),
|
||||
|
||||
context_evolution=[] # Placeholder for temporal versioning
|
||||
)
|
||||
|
||||
# Cache the result
|
||||
self.resolution_cache[ucxl_address] = result
|
||||
|
||||
return result
|
||||
|
||||
def ucxl_to_filesystem_path(self, ucxl_address: str) -> Optional[str]:
|
||||
"""Convert UCXL address to filesystem path"""
|
||||
|
||||
# Parse UCXL address: ucxl://agent:role@project:task/path
|
||||
if not ucxl_address.startswith("ucxl://"):
|
||||
return None
|
||||
|
||||
try:
|
||||
# Remove scheme
|
||||
remainder = ucxl_address[7:] # Remove "ucxl://"
|
||||
|
||||
# Split by @ to separate authority and path
|
||||
if '@' not in remainder:
|
||||
return None
|
||||
|
||||
authority_part, path_part = remainder.split('@', 1)
|
||||
|
||||
# Split by first / to separate project:task from path
|
||||
if '/' in path_part:
|
||||
project_task, file_path = path_part.split('/', 1)
|
||||
|
||||
# Look for matching path in our metadata
|
||||
for fs_path, meta in self.path_metadata.items():
|
||||
if meta['ucxl_address'] == ucxl_address:
|
||||
return fs_path
|
||||
|
||||
# If not found, try to construct from UCXL path
|
||||
# This is project-specific logic for BZZZ
|
||||
if project_task == "BZZZ:RUSTLE-testing":
|
||||
base_path = "/home/tony/chorus/project-queues/active/BZZZ" # Could be configurable
|
||||
constructed_path = str(Path(base_path) / file_path)
|
||||
if constructed_path in self.path_metadata:
|
||||
return constructed_path
|
||||
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Error parsing UCXL address {ucxl_address}: {e}")
|
||||
return None
|
||||
|
||||
def resolve_cascading_context(self, filesystem_path: str, max_depth: int = 10) -> Optional[Dict[str, Any]]:
|
||||
"""Resolve context by walking up the directory hierarchy with bounded traversal"""
|
||||
|
||||
current_path = Path(filesystem_path)
|
||||
if not current_path.is_dir():
|
||||
current_path = current_path.parent
|
||||
|
||||
contexts = []
|
||||
inheritance_chain = []
|
||||
depth = 0
|
||||
|
||||
# First, check for global contexts
|
||||
global_contexts = self._get_global_contexts()
|
||||
|
||||
# Walk up the directory tree with bounded depth
|
||||
while depth < max_depth:
|
||||
path_str = str(current_path)
|
||||
|
||||
if path_str in self.context_hierarchy:
|
||||
context_node = self.context_hierarchy[path_str]
|
||||
contexts.append(context_node)
|
||||
inheritance_chain.append(path_str)
|
||||
|
||||
# Stop if this context doesn't cascade to children
|
||||
if not context_node.get('applies_to_children', True):
|
||||
break
|
||||
|
||||
# Stop if this context overrides parent
|
||||
if context_node.get('overrides_parent', False):
|
||||
break
|
||||
|
||||
# Move up one level
|
||||
parent = current_path.parent
|
||||
if parent == current_path: # Reached filesystem root
|
||||
break
|
||||
current_path = parent
|
||||
depth += 1
|
||||
|
||||
# Add global contexts (they apply everywhere)
|
||||
contexts.extend(global_contexts)
|
||||
|
||||
if not contexts:
|
||||
return None
|
||||
|
||||
# Merge contexts (most specific first, global contexts last)
|
||||
merged_context = self.merge_contexts(contexts)
|
||||
merged_context['inheritance_chain'] = inheritance_chain
|
||||
merged_context['source_path'] = inheritance_chain[0] if inheritance_chain else filesystem_path
|
||||
merged_context['confidence'] = min(1.0, len(contexts) * 0.2 + 0.6) # Higher confidence with more context layers
|
||||
merged_context['bounded_depth'] = depth
|
||||
merged_context['global_contexts_applied'] = len(global_contexts) > 0
|
||||
|
||||
return merged_context
|
||||
|
||||
def merge_contexts(self, contexts: List[Dict[str, Any]]) -> Dict[str, Any]:
|
||||
"""Merge multiple contexts using CSS-like specificity"""
|
||||
|
||||
if len(contexts) == 1:
|
||||
return contexts[0].copy()
|
||||
|
||||
# Sort by specificity (higher = more specific)
|
||||
contexts.sort(key=lambda c: c.get('context_specificity', 0), reverse=True)
|
||||
|
||||
# Start with most specific context
|
||||
merged = contexts[0].copy()
|
||||
|
||||
# Merge in less specific contexts
|
||||
for context in contexts[1:]:
|
||||
# Tags are additive (union)
|
||||
merged_tags = set(merged.get('tags', []))
|
||||
merged_tags.update(context.get('tags', []))
|
||||
merged['tags'] = list(merged_tags)
|
||||
|
||||
# Technologies are additive (union)
|
||||
merged_tech = set(merged.get('technologies', []))
|
||||
merged_tech.update(context.get('technologies', []))
|
||||
merged['technologies'] = list(merged_tech)
|
||||
|
||||
# Insights are additive (append unique)
|
||||
merged_insights = merged.get('insights', []).copy()
|
||||
for insight in context.get('insights', []):
|
||||
if insight not in merged_insights:
|
||||
merged_insights.append(insight)
|
||||
merged['insights'] = merged_insights
|
||||
|
||||
# Use most specific for summary/purpose unless empty
|
||||
if not merged.get('summary'):
|
||||
merged['summary'] = context.get('summary', '')
|
||||
if not merged.get('purpose'):
|
||||
merged['purpose'] = context.get('purpose', '')
|
||||
|
||||
return merged
|
||||
|
||||
def _get_global_contexts(self) -> List[Dict[str, Any]]:
|
||||
"""Get contexts marked as global (apply everywhere)"""
|
||||
return [context for context in self.global_contexts
|
||||
if context.get('is_global', False)]
|
||||
|
||||
def add_global_context(self, context: Dict[str, Any]) -> None:
|
||||
"""Add a context that applies globally to all paths"""
|
||||
context['is_global'] = True
|
||||
context['context_specificity'] = -1 # Lowest specificity
|
||||
self.global_contexts.append(context)
|
||||
self.clear_cache() # Clear cache since global context affects everything
|
||||
|
||||
def remove_global_context(self, context_id: str) -> bool:
|
||||
"""Remove a global context by its ID"""
|
||||
initial_count = len(self.global_contexts)
|
||||
self.global_contexts = [ctx for ctx in self.global_contexts
|
||||
if ctx.get('id') != context_id]
|
||||
if len(self.global_contexts) < initial_count:
|
||||
self.clear_cache()
|
||||
return True
|
||||
return False
|
||||
|
||||
def set_hierarchy_depth_limit(self, max_depth: int) -> None:
|
||||
"""Set the maximum depth for hierarchy traversal"""
|
||||
self.max_hierarchy_depth = max_depth
|
||||
self.clear_cache() # Clear cache since depth limit affects resolution
|
||||
|
||||
def get_context_statistics(self) -> Dict[str, Any]:
|
||||
"""Get statistics about the loaded context system"""
|
||||
|
||||
return {
|
||||
'context_nodes': len(self.context_hierarchy),
|
||||
'path_entries': len(self.path_metadata),
|
||||
'lookup_entries': len(self.lookup_index),
|
||||
'cached_resolutions': len(self.resolution_cache),
|
||||
'global_contexts': len(self.global_contexts),
|
||||
'max_hierarchy_depth': self.max_hierarchy_depth,
|
||||
'metadata_directory': str(self.metadata_dir)
|
||||
}
|
||||
|
||||
def clear_cache(self) -> None:
|
||||
"""Clear the resolution cache"""
|
||||
self.resolution_cache.clear()
|
||||
|
||||
def batch_resolve(self, ucxl_addresses: List[str]) -> Dict[str, ResolvedContext]:
|
||||
"""Efficiently resolve multiple UCXL addresses"""
|
||||
|
||||
results = {}
|
||||
|
||||
for address in ucxl_addresses:
|
||||
context = self.resolve(address)
|
||||
if context:
|
||||
results[address] = context
|
||||
|
||||
return results
|
||||
|
||||
def search_by_tag(self, tag: str) -> List[ResolvedContext]:
|
||||
"""Find all contexts containing a specific tag"""
|
||||
|
||||
results = []
|
||||
|
||||
# Search through all path metadata
|
||||
for fs_path, meta in self.path_metadata.items():
|
||||
ucxl_address = meta.get('ucxl_address')
|
||||
if not ucxl_address:
|
||||
continue
|
||||
|
||||
context = self.resolve(ucxl_address)
|
||||
if context and tag.lower() in [t.lower() for t in context.tags]:
|
||||
results.append(context)
|
||||
|
||||
return results
|
||||
|
||||
def search_by_technology(self, technology: str) -> List[ResolvedContext]:
|
||||
"""Find all contexts using a specific technology"""
|
||||
|
||||
results = []
|
||||
|
||||
for fs_path, meta in self.path_metadata.items():
|
||||
ucxl_address = meta.get('ucxl_address')
|
||||
if not ucxl_address:
|
||||
continue
|
||||
|
||||
context = self.resolve(ucxl_address)
|
||||
if context and technology.lower() in [t.lower() for t in context.technologies]:
|
||||
results.append(context)
|
||||
|
||||
return results
|
||||
|
||||
# Example usage and demo
|
||||
def demo_context_resolution():
|
||||
"""Demonstrate the cascading context resolution system"""
|
||||
|
||||
metadata_dir = Path.home() / "chorus" / "project-metadata" / "BZZZ"
|
||||
|
||||
if not metadata_dir.exists():
|
||||
logger.error(f"Metadata directory not found: {metadata_dir}")
|
||||
logger.info("Run cascading_metadata_generator.py first to generate the hierarchy")
|
||||
return
|
||||
|
||||
resolver = CascadingContextResolver(str(metadata_dir))
|
||||
|
||||
# Demo UCXL addresses
|
||||
demo_addresses = [
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/src/main.rs",
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/src/api/handlers.rs",
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/tests/unit/core_tests.rs",
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/assets/fonts/README.md",
|
||||
"ucxl://any:any@BZZZ:RUSTLE-testing/config/settings.toml"
|
||||
]
|
||||
|
||||
logger.info("🔍 Context Resolution Demo")
|
||||
logger.info("=" * 50)
|
||||
|
||||
for address in demo_addresses:
|
||||
logger.info(f"\n🔗 Resolving: {address}")
|
||||
|
||||
context = resolver.resolve(address)
|
||||
if context:
|
||||
logger.info(f" 📝 Summary: {context.summary}")
|
||||
logger.info(f" 🎯 Purpose: {context.purpose}")
|
||||
logger.info(f" 🔧 Technologies: {', '.join(context.technologies[:3])}")
|
||||
logger.info(f" 🏷️ Tags: {', '.join(context.tags[:5])}")
|
||||
logger.info(f" 📊 Source: {Path(context.context_source_path).name}")
|
||||
logger.info(f" 🔗 Chain: {' → '.join([Path(p).name for p in context.inheritance_chain])}")
|
||||
logger.info(f" ✨ Confidence: {context.resolution_confidence:.2f}")
|
||||
else:
|
||||
logger.warning(f" ❌ Could not resolve context")
|
||||
|
||||
# Show statistics
|
||||
stats = resolver.get_context_statistics()
|
||||
logger.info(f"\n📊 System Statistics:")
|
||||
logger.info(f" 🏗️ Context nodes: {stats['context_nodes']}")
|
||||
logger.info(f" 📄 Path entries: {stats['path_entries']}")
|
||||
logger.info(f" 🔍 Lookup entries: {stats['lookup_entries']}")
|
||||
logger.info(f" 💾 Cached resolutions: {stats['cached_resolutions']}")
|
||||
|
||||
# Demo search functionality
|
||||
logger.info(f"\n🔎 Search Demo:")
|
||||
rust_contexts = resolver.search_by_technology("rust")
|
||||
logger.info(f" 🦀 Found {len(rust_contexts)} Rust contexts")
|
||||
|
||||
source_contexts = resolver.search_by_tag("source-code")
|
||||
logger.info(f" 💻 Found {len(source_contexts)} source code contexts")
|
||||
|
||||
if __name__ == "__main__":
|
||||
logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(message)s')
|
||||
demo_context_resolution()
|
||||
Reference in New Issue
Block a user