mirror of
https://github.com/mhattingpete/claude-skills-marketplace.git
synced 2026-11-20 12:23:27 +00:00
* feat(setup): add Claude Code support with config detection 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * feat(execution-runtime): add Claude Code direct import support 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * refactor(execution-runtime): remove Claude Desktop support, focus on Claude Code only 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> --------- Co-authored-by: Claude <noreply@anthropic.com>
197 lines
5.0 KiB
Python
197 lines
5.0 KiB
Python
"""
|
|
Session management for multi-step refactoring operations.
|
|
|
|
Stateful sessions allow complex refactoring work to be saved and resumed if interrupted.
|
|
"""
|
|
|
|
import json
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
from typing import Dict, Optional, List
|
|
|
|
|
|
SESSIONS_DIR = Path.home() / ".claude" / "execution-runtime" / "sessions"
|
|
|
|
|
|
class Session:
|
|
"""
|
|
Stateful refactoring session for multi-step operations.
|
|
|
|
Example:
|
|
>>> session = Session("modernize-codebase", "Update to Python 3.11+ syntax")
|
|
>>> session.save_state({'processed': ['a.py', 'b.py'], 'remaining': ['c.py']})
|
|
>>> state = session.load_state()
|
|
>>> print(state['processed'])
|
|
['a.py', 'b.py']
|
|
"""
|
|
|
|
def __init__(self, name: str, description: str = ""):
|
|
"""
|
|
Create or load session.
|
|
|
|
Args:
|
|
name: Unique session identifier
|
|
description: Optional description of the refactoring work
|
|
"""
|
|
self.name = name
|
|
self.description = description
|
|
self.session_file = SESSIONS_DIR / f"{name}.json"
|
|
|
|
SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
|
|
|
|
if not self.session_file.exists():
|
|
self._create_new()
|
|
|
|
def _create_new(self):
|
|
"""Create new session file."""
|
|
data = {
|
|
"name": self.name,
|
|
"description": self.description,
|
|
"created_at": datetime.now().isoformat(),
|
|
"state": {},
|
|
"history": []
|
|
}
|
|
self.session_file.write_text(json.dumps(data, indent=2))
|
|
|
|
def save_state(self, state: Dict):
|
|
"""
|
|
Save current state to disk.
|
|
|
|
Args:
|
|
state: State dictionary to save. Can contain any JSON-serializable data.
|
|
|
|
Example:
|
|
>>> session.save_state({
|
|
... 'files_processed': ['a.py', 'b.py'],
|
|
... 'files_remaining': ['c.py', 'd.py'],
|
|
... 'operations_completed': 45
|
|
... })
|
|
"""
|
|
data = json.loads(self.session_file.read_text())
|
|
data["state"] = state
|
|
data["updated_at"] = datetime.now().isoformat()
|
|
data["history"].append({
|
|
"timestamp": datetime.now().isoformat(),
|
|
"state_snapshot": state
|
|
})
|
|
self.session_file.write_text(json.dumps(data, indent=2))
|
|
|
|
def load_state(self) -> Dict:
|
|
"""
|
|
Load current state from disk.
|
|
|
|
Returns:
|
|
Current state dictionary
|
|
|
|
Example:
|
|
>>> state = session.load_state()
|
|
>>> print(state.get('files_processed', []))
|
|
['a.py', 'b.py']
|
|
"""
|
|
data = json.loads(self.session_file.read_text())
|
|
return data.get("state", {})
|
|
|
|
def get_history(self) -> List[Dict]:
|
|
"""
|
|
Get session history with timestamps.
|
|
|
|
Returns:
|
|
List of historical state snapshots with timestamps
|
|
|
|
Example:
|
|
>>> history = session.get_history()
|
|
>>> for entry in history:
|
|
... print(f"{entry['timestamp']}: {entry['state_snapshot']}")
|
|
"""
|
|
data = json.loads(self.session_file.read_text())
|
|
return data.get("history", [])
|
|
|
|
def delete(self):
|
|
"""Delete this session."""
|
|
if self.session_file.exists():
|
|
self.session_file.unlink()
|
|
|
|
@property
|
|
def exists(self) -> bool:
|
|
"""Check if session file exists."""
|
|
return self.session_file.exists()
|
|
|
|
@property
|
|
def path(self) -> str:
|
|
"""Get session file path."""
|
|
return str(self.session_file)
|
|
|
|
|
|
def create_session(name: str, description: str = "") -> Session:
|
|
"""
|
|
Create new refactoring session.
|
|
|
|
Args:
|
|
name: Unique session identifier
|
|
description: Optional description
|
|
|
|
Returns:
|
|
Session object
|
|
|
|
Example:
|
|
>>> session = create_session("rename-api-functions", "Rename all API functions")
|
|
>>> session.save_state({'progress': 50})
|
|
"""
|
|
return Session(name, description)
|
|
|
|
|
|
def load_session(name: str) -> Session:
|
|
"""
|
|
Load existing session.
|
|
|
|
Args:
|
|
name: Session identifier
|
|
|
|
Returns:
|
|
Session object
|
|
|
|
Raises:
|
|
FileNotFoundError: If session doesn't exist
|
|
|
|
Example:
|
|
>>> session = load_session("rename-api-functions")
|
|
>>> state = session.load_state()
|
|
"""
|
|
session_file = SESSIONS_DIR / f"{name}.json"
|
|
if not session_file.exists():
|
|
raise FileNotFoundError(f"Session '{name}' not found")
|
|
|
|
return Session(name)
|
|
|
|
|
|
def list_sessions() -> List[str]:
|
|
"""
|
|
List all available sessions.
|
|
|
|
Returns:
|
|
List of session names
|
|
|
|
Example:
|
|
>>> sessions = list_sessions()
|
|
>>> for name in sessions:
|
|
... print(f"Session: {name}")
|
|
"""
|
|
if not SESSIONS_DIR.exists():
|
|
return []
|
|
|
|
return [f.stem for f in SESSIONS_DIR.glob("*.json")]
|
|
|
|
|
|
def delete_session(name: str):
|
|
"""
|
|
Delete a session.
|
|
|
|
Args:
|
|
name: Session identifier
|
|
|
|
Example:
|
|
>>> delete_session("old-refactoring-work")
|
|
"""
|
|
session = Session(name)
|
|
session.delete()
|