Initial commit: Clean DSS implementation
Migrated from design-system-swarm with fresh git history.
Old project history preserved in /home/overbits/apps/design-system-swarm
Core components:
- MCP Server (Python FastAPI with mcp 1.23.1)
- Claude Plugin (agents, commands, skills, strategies, hooks, core)
- DSS Backend (dss-mvp1 - token translation, Figma sync)
- Admin UI (Node.js/React)
- Server (Node.js/Express)
- Storybook integration (dss-mvp1/.storybook)
Self-contained configuration:
- All paths relative or use DSS_BASE_PATH=/home/overbits/dss
- PYTHONPATH configured for dss-mvp1 and dss-claude-plugin
- .env file with all configuration
- Claude plugin uses ${CLAUDE_PLUGIN_ROOT} for portability
Migration completed: $(date)
🤖 Clean migration with full functionality preserved
This commit is contained in:
Digital Production Factory
443
demo/tools/dss_mcp/context/project_context.py
Normal file
443
demo/tools/dss_mcp/context/project_context.py
Normal file
@@ -0,0 +1,443 @@
|
||||
"""
|
||||
Project Context Manager
|
||||
|
||||
Provides cached, project-isolated context for Claude MCP sessions.
|
||||
Loads all relevant project data (components, tokens, config, health, etc.)
|
||||
and caches it for performance.
|
||||
"""
|
||||
|
||||
import json
|
||||
import asyncio
|
||||
from datetime import datetime, timedelta
|
||||
from dataclasses import dataclass, asdict
|
||||
from typing import Dict, Any, Optional, List
|
||||
from pathlib import Path
|
||||
|
||||
# Import from existing DSS modules
|
||||
import sys
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent.parent))
|
||||
|
||||
from storage.database import get_connection, Projects
|
||||
from analyze.scanner import ProjectScanner
|
||||
from ..config import mcp_config
|
||||
|
||||
|
||||
@dataclass
|
||||
class ProjectContext:
|
||||
"""Complete project context for MCP sessions"""
|
||||
|
||||
project_id: str
|
||||
name: str
|
||||
description: Optional[str]
|
||||
path: Optional[Path]
|
||||
|
||||
# Component data
|
||||
components: List[Dict[str, Any]]
|
||||
component_count: int
|
||||
|
||||
# Token/Style data
|
||||
tokens: Dict[str, Any]
|
||||
styles: List[Dict[str, Any]]
|
||||
|
||||
# Project configuration
|
||||
config: Dict[str, Any]
|
||||
|
||||
# User's enabled integrations (user-scoped)
|
||||
integrations: Dict[str, Any]
|
||||
|
||||
# Project health & metrics
|
||||
health: Dict[str, Any]
|
||||
stats: Dict[str, Any]
|
||||
|
||||
# Discovery/scan results
|
||||
discovery: Dict[str, Any]
|
||||
|
||||
# Metadata
|
||||
loaded_at: datetime
|
||||
cache_expires_at: datetime
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
"""Convert to dictionary for JSON serialization"""
|
||||
data = asdict(self)
|
||||
data['loaded_at'] = self.loaded_at.isoformat()
|
||||
data['cache_expires_at'] = self.cache_expires_at.isoformat()
|
||||
if self.path:
|
||||
data['path'] = str(self.path)
|
||||
return data
|
||||
|
||||
def is_expired(self) -> bool:
|
||||
"""Check if cache has expired"""
|
||||
return datetime.now() >= self.cache_expires_at
|
||||
|
||||
|
||||
class ProjectContextManager:
|
||||
"""
|
||||
Manages project contexts with TTL-based caching.
|
||||
|
||||
Provides fast access to project data for MCP tools while ensuring
|
||||
data freshness and project isolation.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self._cache: Dict[str, ProjectContext] = {}
|
||||
self._cache_ttl = timedelta(seconds=mcp_config.CONTEXT_CACHE_TTL)
|
||||
|
||||
async def get_context(
|
||||
self,
|
||||
project_id: str,
|
||||
user_id: Optional[int] = None,
|
||||
force_refresh: bool = False
|
||||
) -> Optional[ProjectContext]:
|
||||
"""
|
||||
Get project context, using cache if available.
|
||||
|
||||
Args:
|
||||
project_id: Project ID
|
||||
user_id: User ID for loading user-scoped integrations
|
||||
force_refresh: Force cache refresh
|
||||
|
||||
Returns:
|
||||
ProjectContext or None if project not found
|
||||
"""
|
||||
# Check cache first
|
||||
cache_key = f"{project_id}:{user_id or 'anonymous'}"
|
||||
if not force_refresh and cache_key in self._cache:
|
||||
ctx = self._cache[cache_key]
|
||||
if not ctx.is_expired():
|
||||
return ctx
|
||||
|
||||
# Load fresh context
|
||||
context = await self._load_context(project_id, user_id)
|
||||
if context:
|
||||
self._cache[cache_key] = context
|
||||
|
||||
return context
|
||||
|
||||
async def _load_context(
|
||||
self,
|
||||
project_id: str,
|
||||
user_id: Optional[int] = None
|
||||
) -> Optional[ProjectContext]:
|
||||
"""Load complete project context from database and filesystem"""
|
||||
|
||||
# Run database queries in thread pool to avoid blocking
|
||||
loop = asyncio.get_event_loop()
|
||||
|
||||
# Load project metadata
|
||||
project = await loop.run_in_executor(None, self._load_project, project_id)
|
||||
if not project:
|
||||
return None
|
||||
|
||||
# Load components, styles, stats in parallel
|
||||
components_task = loop.run_in_executor(None, self._load_components, project_id)
|
||||
styles_task = loop.run_in_executor(None, self._load_styles, project_id)
|
||||
stats_task = loop.run_in_executor(None, self._load_stats, project_id)
|
||||
integrations_task = loop.run_in_executor(None, self._load_integrations, project_id, user_id)
|
||||
|
||||
components = await components_task
|
||||
styles = await styles_task
|
||||
stats = await stats_task
|
||||
integrations = await integrations_task
|
||||
|
||||
# Load tokens from filesystem if project has a path
|
||||
tokens = {}
|
||||
project_path = None
|
||||
if project.get('figma_file_key'):
|
||||
# Try to find project path based on naming convention
|
||||
# (This can be enhanced based on actual project structure)
|
||||
project_path = Path.cwd()
|
||||
tokens = await loop.run_in_executor(None, self._load_tokens, project_path)
|
||||
|
||||
# Load discovery/scan data
|
||||
discovery = await loop.run_in_executor(None, self._load_discovery, project_path)
|
||||
|
||||
# Compute health score
|
||||
health = self._compute_health(components, tokens, stats)
|
||||
|
||||
# Build context
|
||||
now = datetime.now()
|
||||
context = ProjectContext(
|
||||
project_id=project_id,
|
||||
name=project['name'],
|
||||
description=project.get('description'),
|
||||
path=project_path,
|
||||
components=components,
|
||||
component_count=len(components),
|
||||
tokens=tokens,
|
||||
styles=styles,
|
||||
config={
|
||||
'figma_file_key': project.get('figma_file_key'),
|
||||
'status': project.get('status', 'active')
|
||||
},
|
||||
integrations=integrations,
|
||||
health=health,
|
||||
stats=stats,
|
||||
discovery=discovery,
|
||||
loaded_at=now,
|
||||
cache_expires_at=now + self._cache_ttl
|
||||
)
|
||||
|
||||
return context
|
||||
|
||||
def _load_project(self, project_id: str) -> Optional[Dict[str, Any]]:
|
||||
"""Load project metadata from database"""
|
||||
try:
|
||||
with get_connection() as conn:
|
||||
row = conn.execute(
|
||||
"SELECT * FROM projects WHERE id = ?",
|
||||
(project_id,)
|
||||
).fetchone()
|
||||
|
||||
if row:
|
||||
return dict(row)
|
||||
return None
|
||||
except Exception as e:
|
||||
print(f"Error loading project: {e}")
|
||||
return None
|
||||
|
||||
def _load_components(self, project_id: str) -> List[Dict[str, Any]]:
|
||||
"""Load all components for project"""
|
||||
try:
|
||||
with get_connection() as conn:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, name, figma_key, description,
|
||||
properties, variants, code_generated,
|
||||
created_at, updated_at
|
||||
FROM components
|
||||
WHERE project_id = ?
|
||||
ORDER BY name
|
||||
""",
|
||||
(project_id,)
|
||||
).fetchall()
|
||||
|
||||
components = []
|
||||
for row in rows:
|
||||
comp = dict(row)
|
||||
# Parse JSON fields
|
||||
if comp.get('properties'):
|
||||
comp['properties'] = json.loads(comp['properties'])
|
||||
if comp.get('variants'):
|
||||
comp['variants'] = json.loads(comp['variants'])
|
||||
components.append(comp)
|
||||
|
||||
return components
|
||||
except Exception as e:
|
||||
print(f"Error loading components: {e}")
|
||||
return []
|
||||
|
||||
def _load_styles(self, project_id: str) -> List[Dict[str, Any]]:
|
||||
"""Load all styles for project"""
|
||||
try:
|
||||
with get_connection() as conn:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, name, type, figma_key, properties, created_at
|
||||
FROM styles
|
||||
WHERE project_id = ?
|
||||
ORDER BY type, name
|
||||
""",
|
||||
(project_id,)
|
||||
).fetchall()
|
||||
|
||||
styles = []
|
||||
for row in rows:
|
||||
style = dict(row)
|
||||
if style.get('properties'):
|
||||
style['properties'] = json.loads(style['properties'])
|
||||
styles.append(style)
|
||||
|
||||
return styles
|
||||
except Exception as e:
|
||||
print(f"Error loading styles: {e}")
|
||||
return []
|
||||
|
||||
def _load_stats(self, project_id: str) -> Dict[str, Any]:
|
||||
"""Load project statistics"""
|
||||
try:
|
||||
with get_connection() as conn:
|
||||
# Component count by type
|
||||
component_stats = conn.execute(
|
||||
"""
|
||||
SELECT COUNT(*) as total,
|
||||
SUM(CASE WHEN code_generated = 1 THEN 1 ELSE 0 END) as generated
|
||||
FROM components
|
||||
WHERE project_id = ?
|
||||
""",
|
||||
(project_id,)
|
||||
).fetchone()
|
||||
|
||||
# Style count by type
|
||||
style_stats = conn.execute(
|
||||
"""
|
||||
SELECT type, COUNT(*) as count
|
||||
FROM styles
|
||||
WHERE project_id = ?
|
||||
GROUP BY type
|
||||
""",
|
||||
(project_id,)
|
||||
).fetchall()
|
||||
|
||||
return {
|
||||
'components': dict(component_stats) if component_stats else {'total': 0, 'generated': 0},
|
||||
'styles': {row['type']: row['count'] for row in style_stats}
|
||||
}
|
||||
except Exception as e:
|
||||
print(f"Error loading stats: {e}")
|
||||
return {'components': {'total': 0, 'generated': 0}, 'styles': {}}
|
||||
|
||||
def _load_integrations(self, project_id: str, user_id: Optional[int]) -> Dict[str, Any]:
|
||||
"""Load user's enabled integrations for this project"""
|
||||
if not user_id:
|
||||
return {}
|
||||
|
||||
try:
|
||||
with get_connection() as conn:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT integration_type, config, enabled, last_used_at
|
||||
FROM project_integrations
|
||||
WHERE project_id = ? AND user_id = ? AND enabled = 1
|
||||
""",
|
||||
(project_id, user_id)
|
||||
).fetchall()
|
||||
|
||||
# Return decrypted config for each integration
|
||||
integrations = {}
|
||||
cipher = mcp_config.get_cipher()
|
||||
|
||||
for row in rows:
|
||||
integration_type = row['integration_type']
|
||||
encrypted_config = row['config']
|
||||
|
||||
# Decrypt config
|
||||
if cipher:
|
||||
try:
|
||||
decrypted_config = cipher.decrypt(encrypted_config.encode()).decode()
|
||||
config = json.loads(decrypted_config)
|
||||
except Exception as e:
|
||||
print(f"Error decrypting integration config: {e}")
|
||||
config = {}
|
||||
else:
|
||||
# No encryption key, try to parse as JSON
|
||||
try:
|
||||
config = json.loads(encrypted_config)
|
||||
except:
|
||||
config = {}
|
||||
|
||||
integrations[integration_type] = {
|
||||
'enabled': True,
|
||||
'config': config,
|
||||
'last_used_at': row['last_used_at']
|
||||
}
|
||||
|
||||
return integrations
|
||||
except Exception as e:
|
||||
print(f"Error loading integrations: {e}")
|
||||
return {}
|
||||
|
||||
def _load_tokens(self, project_path: Optional[Path]) -> Dict[str, Any]:
|
||||
"""Load design tokens from filesystem"""
|
||||
if not project_path:
|
||||
return {}
|
||||
|
||||
tokens = {}
|
||||
token_files = ['tokens.json', 'design-tokens.json', 'variables.json']
|
||||
|
||||
for token_file in token_files:
|
||||
token_path = project_path / token_file
|
||||
if token_path.exists():
|
||||
try:
|
||||
with open(token_path) as f:
|
||||
tokens = json.load(f)
|
||||
break
|
||||
except Exception as e:
|
||||
print(f"Error loading tokens from {token_path}: {e}")
|
||||
|
||||
return tokens
|
||||
|
||||
def _load_discovery(self, project_path: Optional[Path]) -> Dict[str, Any]:
|
||||
"""Load project discovery data"""
|
||||
if not project_path:
|
||||
return {}
|
||||
|
||||
try:
|
||||
scanner = ProjectScanner(str(project_path))
|
||||
discovery = scanner.scan()
|
||||
return discovery
|
||||
except Exception as e:
|
||||
print(f"Error running discovery scan: {e}")
|
||||
return {}
|
||||
|
||||
def _compute_health(
|
||||
self,
|
||||
components: List[Dict],
|
||||
tokens: Dict,
|
||||
stats: Dict
|
||||
) -> Dict[str, Any]:
|
||||
"""Compute project health score"""
|
||||
score = 100
|
||||
issues = []
|
||||
|
||||
# Deduct points for missing components
|
||||
if stats['components']['total'] == 0:
|
||||
score -= 30
|
||||
issues.append("No components defined")
|
||||
|
||||
# Deduct points for no tokens
|
||||
if not tokens:
|
||||
score -= 20
|
||||
issues.append("No design tokens defined")
|
||||
|
||||
# Deduct points for ungeneratedcomponents
|
||||
total = stats['components']['total']
|
||||
generated = stats['components']['generated']
|
||||
if total > 0 and generated < total:
|
||||
percentage = (generated / total) * 100
|
||||
if percentage < 50:
|
||||
score -= 20
|
||||
issues.append(f"Low code generation: {percentage:.1f}%")
|
||||
elif percentage < 80:
|
||||
score -= 10
|
||||
issues.append(f"Medium code generation: {percentage:.1f}%")
|
||||
|
||||
# Compute grade
|
||||
if score >= 90:
|
||||
grade = 'A'
|
||||
elif score >= 80:
|
||||
grade = 'B'
|
||||
elif score >= 70:
|
||||
grade = 'C'
|
||||
elif score >= 60:
|
||||
grade = 'D'
|
||||
else:
|
||||
grade = 'F'
|
||||
|
||||
return {
|
||||
'score': max(0, score),
|
||||
'grade': grade,
|
||||
'issues': issues
|
||||
}
|
||||
|
||||
def clear_cache(self, project_id: Optional[str] = None):
|
||||
"""Clear cache for specific project or all projects"""
|
||||
if project_id:
|
||||
# Clear all cache entries for this project
|
||||
keys_to_remove = [k for k in self._cache.keys() if k.startswith(f"{project_id}:")]
|
||||
for key in keys_to_remove:
|
||||
del self._cache[key]
|
||||
else:
|
||||
# Clear all cache
|
||||
self._cache.clear()
|
||||
|
||||
|
||||
# Singleton instance
|
||||
_context_manager = None
|
||||
|
||||
|
||||
def get_context_manager() -> ProjectContextManager:
|
||||
"""Get singleton context manager instance"""
|
||||
global _context_manager
|
||||
if _context_manager is None:
|
||||
_context_manager = ProjectContextManager()
|
||||
return _context_manager
|
||||
Reference in New Issue
Block a user