987 lines
33 KiB
Python
Executable File
987 lines
33 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Workflow versioning system with task session tracking.
|
|
Links workflow sessions with task sessions and individual operations.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import shutil
|
|
import sys
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
# Try to import yaml
|
|
try:
|
|
import yaml
|
|
HAS_YAML = True
|
|
except ImportError:
|
|
HAS_YAML = False
|
|
|
|
|
|
# ============================================================================
|
|
# YAML/JSON Helpers
|
|
# ============================================================================
|
|
|
|
def load_yaml(filepath: str) -> dict:
|
|
"""Load YAML file."""
|
|
if not os.path.exists(filepath):
|
|
return {}
|
|
with open(filepath, 'r') as f:
|
|
content = f.read()
|
|
if not content.strip():
|
|
return {}
|
|
if HAS_YAML:
|
|
return yaml.safe_load(content) or {}
|
|
# Simple YAML fallback parser for basic key: value structures
|
|
return parse_simple_yaml(content)
|
|
|
|
|
|
def parse_simple_yaml(content: str) -> dict:
|
|
"""Parse simple YAML without PyYAML dependency."""
|
|
result = {}
|
|
current_key = None
|
|
current_list = None
|
|
|
|
for line in content.split('\n'):
|
|
stripped = line.strip()
|
|
|
|
# Skip empty lines and comments
|
|
if not stripped or stripped.startswith('#'):
|
|
continue
|
|
|
|
# Handle list items
|
|
if stripped.startswith('- '):
|
|
if current_list is not None:
|
|
value = stripped[2:].strip()
|
|
# Handle quoted strings
|
|
if (value.startswith('"') and value.endswith('"')) or \
|
|
(value.startswith("'") and value.endswith("'")):
|
|
value = value[1:-1]
|
|
current_list.append(value)
|
|
continue
|
|
|
|
# Handle key: value
|
|
if ':' in stripped:
|
|
key, _, value = stripped.partition(':')
|
|
key = key.strip()
|
|
value = value.strip()
|
|
|
|
# Check if this is a list start
|
|
if value == '' or value == '[]':
|
|
current_key = key
|
|
current_list = []
|
|
result[key] = current_list
|
|
elif value == '{}':
|
|
result[key] = {}
|
|
current_list = None
|
|
elif value == 'null' or value == '~':
|
|
result[key] = None
|
|
current_list = None
|
|
elif value == 'true':
|
|
result[key] = True
|
|
current_list = None
|
|
elif value == 'false':
|
|
result[key] = False
|
|
current_list = None
|
|
elif value.isdigit():
|
|
result[key] = int(value)
|
|
current_list = None
|
|
else:
|
|
# Handle quoted strings
|
|
if (value.startswith('"') and value.endswith('"')) or \
|
|
(value.startswith("'") and value.endswith("'")):
|
|
value = value[1:-1]
|
|
result[key] = value
|
|
current_list = None
|
|
|
|
return result
|
|
|
|
|
|
def save_yaml(filepath: str, data: dict):
|
|
"""Save data to YAML file."""
|
|
os.makedirs(os.path.dirname(filepath), exist_ok=True)
|
|
if HAS_YAML:
|
|
with open(filepath, 'w') as f:
|
|
yaml.dump(data, f, default_flow_style=False, sort_keys=False, allow_unicode=True)
|
|
else:
|
|
with open(filepath, 'w') as f:
|
|
json.dump(data, f, indent=2)
|
|
|
|
|
|
def file_hash(filepath: str) -> str:
|
|
"""Get SHA256 hash of file content."""
|
|
if not os.path.exists(filepath):
|
|
return None
|
|
with open(filepath, 'rb') as f:
|
|
return hashlib.sha256(f.read()).hexdigest()[:16]
|
|
|
|
|
|
# ============================================================================
|
|
# Path Helpers
|
|
# ============================================================================
|
|
|
|
def get_workflow_dir() -> Path:
|
|
return Path('.workflow')
|
|
|
|
|
|
def get_versions_dir() -> Path:
|
|
return get_workflow_dir() / 'versions'
|
|
|
|
|
|
def get_index_path() -> Path:
|
|
return get_workflow_dir() / 'index.yml'
|
|
|
|
|
|
def get_operations_log_path() -> Path:
|
|
return get_workflow_dir() / 'operations.log'
|
|
|
|
|
|
def get_version_dir(version: str) -> Path:
|
|
return get_versions_dir() / version
|
|
|
|
|
|
def get_current_state_path() -> Path:
|
|
return get_workflow_dir() / 'current.yml'
|
|
|
|
|
|
def get_version_tasks_dir(version: str) -> Path:
|
|
"""Get the tasks directory for a specific version."""
|
|
return get_version_dir(version) / 'tasks'
|
|
|
|
|
|
def get_current_tasks_dir() -> Optional[Path]:
|
|
"""Get the tasks directory for the currently active version."""
|
|
current_path = get_current_state_path()
|
|
if not current_path.exists():
|
|
return None
|
|
current = load_yaml(str(current_path))
|
|
version = current.get('active_version')
|
|
if not version:
|
|
return None
|
|
tasks_dir = get_version_tasks_dir(version)
|
|
tasks_dir.mkdir(parents=True, exist_ok=True)
|
|
return tasks_dir
|
|
|
|
|
|
# ============================================================================
|
|
# Version Index Management
|
|
# ============================================================================
|
|
|
|
def load_index() -> dict:
|
|
"""Load or create version index."""
|
|
index_path = get_index_path()
|
|
if index_path.exists():
|
|
return load_yaml(str(index_path))
|
|
return {
|
|
'versions': [],
|
|
'latest_version': None,
|
|
'total_versions': 0
|
|
}
|
|
|
|
|
|
def save_index(index: dict):
|
|
"""Save version index."""
|
|
save_yaml(str(get_index_path()), index)
|
|
|
|
|
|
def get_next_version() -> str:
|
|
"""Get next version number."""
|
|
index = load_index()
|
|
return f"v{index['total_versions'] + 1:03d}"
|
|
|
|
|
|
# ============================================================================
|
|
# Workflow Session Management
|
|
# ============================================================================
|
|
|
|
def create_workflow_session(feature: str, parent_version: str = None) -> dict:
|
|
"""Create a new workflow session with version tracking."""
|
|
now = datetime.now()
|
|
version = get_next_version()
|
|
session_id = f"workflow_{now.strftime('%Y%m%d_%H%M%S')}"
|
|
|
|
# Create version directory and tasks subdirectory
|
|
version_dir = get_version_dir(version)
|
|
version_dir.mkdir(parents=True, exist_ok=True)
|
|
(version_dir / 'tasks').mkdir(exist_ok=True)
|
|
|
|
# Create workflow session
|
|
session = {
|
|
'version': version,
|
|
'feature': feature,
|
|
'session_id': session_id,
|
|
'parent_version': parent_version,
|
|
'status': 'pending',
|
|
'started_at': now.isoformat(),
|
|
'completed_at': None,
|
|
'current_phase': 'INITIALIZING',
|
|
'approvals': {
|
|
'design': {
|
|
'status': 'pending',
|
|
'approved_by': None,
|
|
'approved_at': None,
|
|
'rejection_reason': None
|
|
},
|
|
'implementation': {
|
|
'status': 'pending',
|
|
'approved_by': None,
|
|
'approved_at': None,
|
|
'rejection_reason': None
|
|
}
|
|
},
|
|
'task_sessions': [],
|
|
'summary': {
|
|
'total_tasks': 0,
|
|
'tasks_completed': 0,
|
|
'entities_created': 0,
|
|
'entities_updated': 0,
|
|
'entities_deleted': 0,
|
|
'files_created': 0,
|
|
'files_updated': 0,
|
|
'files_deleted': 0
|
|
}
|
|
}
|
|
|
|
# Save session to version directory
|
|
save_yaml(str(version_dir / 'session.yml'), session)
|
|
|
|
# Update current state pointer
|
|
get_workflow_dir().mkdir(exist_ok=True)
|
|
save_yaml(str(get_current_state_path()), {
|
|
'active_version': version,
|
|
'session_id': session_id
|
|
})
|
|
|
|
# Update index
|
|
index = load_index()
|
|
index['versions'].append({
|
|
'version': version,
|
|
'feature': feature,
|
|
'status': 'pending',
|
|
'started_at': now.isoformat(),
|
|
'completed_at': None,
|
|
'tasks_count': 0,
|
|
'operations_count': 0
|
|
})
|
|
index['latest_version'] = version
|
|
index['total_versions'] += 1
|
|
save_index(index)
|
|
|
|
# Take snapshot of current state (manifest, tasks)
|
|
take_snapshot(version, 'before')
|
|
|
|
return session
|
|
|
|
|
|
def load_current_session() -> Optional[dict]:
|
|
"""Load the current active workflow session."""
|
|
current_path = get_current_state_path()
|
|
if not current_path.exists():
|
|
return None
|
|
|
|
current = load_yaml(str(current_path))
|
|
version = current.get('active_version')
|
|
if not version:
|
|
return None
|
|
|
|
session_path = get_version_dir(version) / 'session.yml'
|
|
if not session_path.exists():
|
|
return None
|
|
|
|
return load_yaml(str(session_path))
|
|
|
|
|
|
def save_current_session(session: dict):
|
|
"""Save the current workflow session."""
|
|
version = session['version']
|
|
session['updated_at'] = datetime.now().isoformat()
|
|
save_yaml(str(get_version_dir(version) / 'session.yml'), session)
|
|
|
|
# Update index
|
|
index = load_index()
|
|
for v in index['versions']:
|
|
if v['version'] == version:
|
|
v['status'] = session['status']
|
|
v['tasks_count'] = session['summary']['total_tasks']
|
|
break
|
|
save_index(index)
|
|
|
|
|
|
def complete_workflow_session(session: dict):
|
|
"""Mark workflow session as completed."""
|
|
now = datetime.now()
|
|
session['status'] = 'completed'
|
|
session['completed_at'] = now.isoformat()
|
|
save_current_session(session)
|
|
|
|
# Take final snapshot
|
|
take_snapshot(session['version'], 'after')
|
|
|
|
# Update index
|
|
index = load_index()
|
|
for v in index['versions']:
|
|
if v['version'] == session['version']:
|
|
v['status'] = 'completed'
|
|
v['completed_at'] = now.isoformat()
|
|
break
|
|
save_index(index)
|
|
|
|
# Clear current pointer
|
|
current_path = get_current_state_path()
|
|
if current_path.exists():
|
|
current_path.unlink()
|
|
|
|
|
|
# ============================================================================
|
|
# Task Session Management
|
|
# ============================================================================
|
|
|
|
def create_task_session(workflow_session: dict, task_id: str, task_type: str, agent: str) -> dict:
|
|
"""Create a new task session with full directory structure."""
|
|
now = datetime.now()
|
|
session_id = f"tasksession_{task_id}_{now.strftime('%Y%m%d_%H%M%S')}"
|
|
|
|
# Create task session DIRECTORY (not file)
|
|
version_dir = get_version_dir(workflow_session['version'])
|
|
task_session_dir = version_dir / 'task_sessions' / task_id
|
|
task_session_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
task_session = {
|
|
'session_id': session_id,
|
|
'workflow_version': workflow_session['version'],
|
|
'task_id': task_id,
|
|
'task_type': task_type,
|
|
'agent': agent,
|
|
'started_at': now.isoformat(),
|
|
'completed_at': None,
|
|
'duration_ms': None,
|
|
'status': 'in_progress',
|
|
'operations': [],
|
|
'review_session': None,
|
|
'errors': [],
|
|
'attempt_number': 1,
|
|
'previous_attempts': []
|
|
}
|
|
|
|
# Save session.yml
|
|
save_yaml(str(task_session_dir / 'session.yml'), task_session)
|
|
|
|
# Snapshot task definition
|
|
snapshot_task_definition(task_id, task_session_dir)
|
|
|
|
# Initialize operations.log
|
|
init_operations_log(task_session_dir, task_id, now)
|
|
|
|
# Link to workflow
|
|
workflow_session['task_sessions'].append(session_id)
|
|
workflow_session['summary']['total_tasks'] += 1
|
|
save_current_session(workflow_session)
|
|
|
|
return task_session
|
|
|
|
|
|
def snapshot_task_definition(task_id: str, task_session_dir: Path):
|
|
"""Snapshot the task definition at execution time."""
|
|
task_file = Path('tasks') / f'{task_id}.yml'
|
|
|
|
if task_file.exists():
|
|
task_data = load_yaml(str(task_file))
|
|
task_data['snapshotted_at'] = datetime.now().isoformat()
|
|
task_data['source_path'] = str(task_file)
|
|
task_data['status_at_snapshot'] = task_data.get('status', 'unknown')
|
|
save_yaml(str(task_session_dir / 'task.yml'), task_data)
|
|
|
|
|
|
def init_operations_log(task_session_dir: Path, task_id: str, start_time: datetime):
|
|
"""Initialize the operations log file."""
|
|
log_path = task_session_dir / 'operations.log'
|
|
header = f"# Operations Log for {task_id}\n"
|
|
header += f"# Started: {start_time.isoformat()}\n"
|
|
header += "# Format: [timestamp] OPERATION target_type: target_id (path)\n"
|
|
header += "=" * 70 + "\n\n"
|
|
with open(log_path, 'w') as f:
|
|
f.write(header)
|
|
|
|
|
|
def log_to_task_operations_log(task_session: dict, operation: dict):
|
|
"""Append operation to task-specific operations log."""
|
|
version = task_session['workflow_version']
|
|
task_id = task_session['task_id']
|
|
log_path = get_version_dir(version) / 'task_sessions' / task_id / 'operations.log'
|
|
|
|
if not log_path.exists():
|
|
return
|
|
|
|
entry = (
|
|
f"[{operation['performed_at']}] "
|
|
f"{operation['type']} {operation['target_type']}: {operation['target_id']}"
|
|
)
|
|
if operation.get('target_path'):
|
|
entry += f" ({operation['target_path']})"
|
|
entry += f"\n Summary: {operation['changes']['diff_summary']}\n"
|
|
|
|
with open(log_path, 'a') as f:
|
|
f.write(entry + "\n")
|
|
|
|
|
|
def load_task_session(version: str, task_id: str) -> Optional[dict]:
|
|
"""Load a task session from directory or flat file (backwards compatible)."""
|
|
# Try new directory structure first
|
|
session_dir = get_version_dir(version) / 'task_sessions' / task_id
|
|
session_path = session_dir / 'session.yml'
|
|
|
|
if session_path.exists():
|
|
return load_yaml(str(session_path))
|
|
|
|
# Fallback to old flat file structure
|
|
old_path = get_version_dir(version) / 'task_sessions' / f'{task_id}.yml'
|
|
if old_path.exists():
|
|
return load_yaml(str(old_path))
|
|
|
|
return None
|
|
|
|
|
|
def save_task_session(task_session: dict):
|
|
"""Save a task session to directory structure."""
|
|
version = task_session['workflow_version']
|
|
task_id = task_session['task_id']
|
|
session_dir = get_version_dir(version) / 'task_sessions' / task_id
|
|
session_dir.mkdir(parents=True, exist_ok=True)
|
|
save_yaml(str(session_dir / 'session.yml'), task_session)
|
|
|
|
|
|
def complete_task_session(task_session: dict, status: str = 'completed'):
|
|
"""Mark task session as completed."""
|
|
now = datetime.now()
|
|
started = datetime.fromisoformat(task_session['started_at'])
|
|
task_session['completed_at'] = now.isoformat()
|
|
task_session['duration_ms'] = int((now - started).total_seconds() * 1000)
|
|
task_session['status'] = status
|
|
save_task_session(task_session)
|
|
|
|
# Update workflow summary
|
|
session = load_current_session()
|
|
if session and status == 'completed':
|
|
session['summary']['tasks_completed'] += 1
|
|
save_current_session(session)
|
|
|
|
|
|
# ============================================================================
|
|
# Operation Logging
|
|
# ============================================================================
|
|
|
|
def log_operation(
|
|
task_session: dict,
|
|
op_type: str, # CREATE, UPDATE, DELETE, RENAME, MOVE
|
|
target_type: str, # file, entity, task, manifest
|
|
target_id: str,
|
|
target_path: str = None,
|
|
before_state: str = None,
|
|
after_state: str = None,
|
|
diff_summary: str = None,
|
|
rollback_data: dict = None
|
|
) -> dict:
|
|
"""Log an operation within a task session."""
|
|
now = datetime.now()
|
|
seq = len(task_session['operations']) + 1
|
|
op_id = f"op_{now.strftime('%Y%m%d_%H%M%S')}_{seq:03d}"
|
|
|
|
operation = {
|
|
'id': op_id,
|
|
'type': op_type,
|
|
'target_type': target_type,
|
|
'target_id': target_id,
|
|
'target_path': target_path,
|
|
'changes': {
|
|
'before': before_state,
|
|
'after': after_state,
|
|
'diff_summary': diff_summary or f"{op_type} {target_type}: {target_id}"
|
|
},
|
|
'performed_at': now.isoformat(),
|
|
'reversible': rollback_data is not None,
|
|
'rollback_data': rollback_data
|
|
}
|
|
|
|
task_session['operations'].append(operation)
|
|
save_task_session(task_session)
|
|
|
|
# Update workflow summary
|
|
session = load_current_session()
|
|
if session:
|
|
if op_type == 'CREATE':
|
|
if target_type == 'file':
|
|
session['summary']['files_created'] += 1
|
|
elif target_type == 'entity':
|
|
session['summary']['entities_created'] += 1
|
|
elif op_type == 'UPDATE':
|
|
if target_type == 'file':
|
|
session['summary']['files_updated'] += 1
|
|
elif target_type == 'entity':
|
|
session['summary']['entities_updated'] += 1
|
|
elif op_type == 'DELETE':
|
|
if target_type == 'file':
|
|
session['summary']['files_deleted'] += 1
|
|
elif target_type == 'entity':
|
|
session['summary']['entities_deleted'] += 1
|
|
save_current_session(session)
|
|
|
|
# Also log to operations log
|
|
log_to_file(operation, task_session)
|
|
|
|
# Also log to task-specific operations log
|
|
log_to_task_operations_log(task_session, operation)
|
|
|
|
# Update index operations count
|
|
index = load_index()
|
|
for v in index['versions']:
|
|
if v['version'] == task_session['workflow_version']:
|
|
v['operations_count'] = v.get('operations_count', 0) + 1
|
|
break
|
|
save_index(index)
|
|
|
|
return operation
|
|
|
|
|
|
def log_to_file(operation: dict, task_session: dict):
|
|
"""Append operation to global operations log."""
|
|
log_path = get_operations_log_path()
|
|
log_entry = (
|
|
f"[{operation['performed_at']}] "
|
|
f"v{task_session['workflow_version']} | "
|
|
f"{task_session['task_id']} | "
|
|
f"{operation['type']} {operation['target_type']}: {operation['target_id']}"
|
|
)
|
|
if operation['target_path']:
|
|
log_entry += f" ({operation['target_path']})"
|
|
log_entry += "\n"
|
|
|
|
with open(log_path, 'a') as f:
|
|
f.write(log_entry)
|
|
|
|
|
|
# ============================================================================
|
|
# Review Session Management
|
|
# ============================================================================
|
|
|
|
def create_review_session(task_session: dict, reviewer: str = 'reviewer') -> dict:
|
|
"""Create a review session for a task."""
|
|
now = datetime.now()
|
|
session_id = f"review_{task_session['task_id']}_{now.strftime('%Y%m%d_%H%M%S')}"
|
|
|
|
review = {
|
|
'session_id': session_id,
|
|
'task_session_id': task_session['session_id'],
|
|
'workflow_version': task_session['workflow_version'],
|
|
'reviewer': reviewer,
|
|
'started_at': now.isoformat(),
|
|
'completed_at': None,
|
|
'decision': None,
|
|
'checks': {
|
|
'file_exists': None,
|
|
'manifest_compliance': None,
|
|
'code_quality': None,
|
|
'lint': None,
|
|
'build': None,
|
|
'tests': None
|
|
},
|
|
'notes': '',
|
|
'issues_found': [],
|
|
'suggestions': []
|
|
}
|
|
|
|
task_session['review_session'] = review
|
|
save_task_session(task_session)
|
|
|
|
return review
|
|
|
|
|
|
def complete_review_session(
|
|
task_session: dict,
|
|
decision: str,
|
|
checks: dict,
|
|
notes: str = '',
|
|
issues: list = None,
|
|
suggestions: list = None
|
|
):
|
|
"""Complete a review session."""
|
|
now = datetime.now()
|
|
review = task_session['review_session']
|
|
review['completed_at'] = now.isoformat()
|
|
review['decision'] = decision
|
|
review['checks'].update(checks)
|
|
review['notes'] = notes
|
|
review['issues_found'] = issues or []
|
|
review['suggestions'] = suggestions or []
|
|
|
|
save_task_session(task_session)
|
|
|
|
|
|
# ============================================================================
|
|
# Snapshots
|
|
# ============================================================================
|
|
|
|
def take_snapshot(version: str, snapshot_type: str):
|
|
"""Take a snapshot of current state (before/after)."""
|
|
snapshot_dir = get_version_dir(version) / f'snapshot_{snapshot_type}'
|
|
snapshot_dir.mkdir(exist_ok=True)
|
|
|
|
# Snapshot manifest
|
|
if os.path.exists('project_manifest.json'):
|
|
shutil.copy('project_manifest.json', snapshot_dir / 'manifest.json')
|
|
|
|
# Snapshot tasks directory
|
|
if os.path.exists('tasks'):
|
|
tasks_snapshot = snapshot_dir / 'tasks'
|
|
if tasks_snapshot.exists():
|
|
shutil.rmtree(tasks_snapshot)
|
|
shutil.copytree('tasks', tasks_snapshot)
|
|
|
|
|
|
# ============================================================================
|
|
# History & Diff
|
|
# ============================================================================
|
|
|
|
def list_versions() -> list:
|
|
"""List all workflow versions."""
|
|
index = load_index()
|
|
return index['versions']
|
|
|
|
|
|
def get_version_details(version: str) -> Optional[dict]:
|
|
"""Get detailed info about a version."""
|
|
session_path = get_version_dir(version) / 'session.yml'
|
|
if not session_path.exists():
|
|
return None
|
|
return load_yaml(str(session_path))
|
|
|
|
|
|
def get_changelog(version: str) -> dict:
|
|
"""Generate changelog for a version."""
|
|
session = get_version_details(version)
|
|
if not session:
|
|
return None
|
|
|
|
changelog = {
|
|
'version': version,
|
|
'feature': session['feature'],
|
|
'status': session['status'],
|
|
'started_at': session['started_at'],
|
|
'completed_at': session['completed_at'],
|
|
'operations': {
|
|
'created': [],
|
|
'updated': [],
|
|
'deleted': []
|
|
},
|
|
'summary': session['summary']
|
|
}
|
|
|
|
# Collect operations from all task sessions
|
|
tasks_dir = get_version_dir(version) / 'task_sessions'
|
|
if tasks_dir.exists():
|
|
for task_file in tasks_dir.glob('*.yml'):
|
|
task = load_yaml(str(task_file))
|
|
for op in task.get('operations', []):
|
|
entry = {
|
|
'type': op['target_type'],
|
|
'id': op['target_id'],
|
|
'path': op['target_path'],
|
|
'task': task['task_id'],
|
|
'agent': task['agent']
|
|
}
|
|
if op['type'] == 'CREATE':
|
|
changelog['operations']['created'].append(entry)
|
|
elif op['type'] == 'UPDATE':
|
|
changelog['operations']['updated'].append(entry)
|
|
elif op['type'] == 'DELETE':
|
|
changelog['operations']['deleted'].append(entry)
|
|
|
|
return changelog
|
|
|
|
|
|
def diff_versions(version1: str, version2: str) -> dict:
|
|
"""Compare two versions."""
|
|
v1 = get_version_details(version1)
|
|
v2 = get_version_details(version2)
|
|
|
|
if not v1 or not v2:
|
|
return None
|
|
|
|
return {
|
|
'from_version': version1,
|
|
'to_version': version2,
|
|
'from_feature': v1['feature'],
|
|
'to_feature': v2['feature'],
|
|
'summary_diff': {
|
|
'entities_created': v2['summary']['entities_created'] - v1['summary']['entities_created'],
|
|
'entities_updated': v2['summary']['entities_updated'] - v1['summary']['entities_updated'],
|
|
'files_created': v2['summary']['files_created'] - v1['summary']['files_created'],
|
|
'files_updated': v2['summary']['files_updated'] - v1['summary']['files_updated']
|
|
}
|
|
}
|
|
|
|
|
|
# ============================================================================
|
|
# Display Functions
|
|
# ============================================================================
|
|
|
|
def show_history():
|
|
"""Display version history."""
|
|
versions = list_versions()
|
|
|
|
print()
|
|
print("╔" + "═" * 70 + "╗")
|
|
print("║" + "WORKFLOW VERSION HISTORY".center(70) + "║")
|
|
print("╠" + "═" * 70 + "╣")
|
|
|
|
if not versions:
|
|
print("║" + " No workflow versions found.".ljust(70) + "║")
|
|
else:
|
|
for v in versions:
|
|
status_icon = "✅" if v['status'] == 'completed' else "🔄" if v['status'] == 'in_progress' else "⏳"
|
|
line1 = f" {status_icon} {v['version']}: {v['feature'][:45]}"
|
|
print("║" + line1.ljust(70) + "║")
|
|
line2 = f" Started: {v['started_at'][:19]} | Tasks: {v['tasks_count']} | Ops: {v.get('operations_count', 0)}"
|
|
print("║" + line2.ljust(70) + "║")
|
|
print("║" + "─" * 70 + "║")
|
|
|
|
print("╚" + "═" * 70 + "╝")
|
|
|
|
|
|
def show_changelog(version: str):
|
|
"""Display changelog for a version."""
|
|
changelog = get_changelog(version)
|
|
if not changelog:
|
|
print(f"Version {version} not found.")
|
|
return
|
|
|
|
print()
|
|
print("╔" + "═" * 70 + "╗")
|
|
print("║" + f"CHANGELOG: {version}".center(70) + "║")
|
|
print("╠" + "═" * 70 + "╣")
|
|
print("║" + f" Feature: {changelog['feature'][:55]}".ljust(70) + "║")
|
|
print("║" + f" Status: {changelog['status']}".ljust(70) + "║")
|
|
print("╠" + "═" * 70 + "╣")
|
|
|
|
ops = changelog['operations']
|
|
print("║" + " CREATED".ljust(70) + "║")
|
|
for item in ops['created']:
|
|
print("║" + f" + [{item['type']}] {item['id']}".ljust(70) + "║")
|
|
if item['path']:
|
|
print("║" + f" {item['path']}".ljust(70) + "║")
|
|
|
|
print("║" + " UPDATED".ljust(70) + "║")
|
|
for item in ops['updated']:
|
|
print("║" + f" ~ [{item['type']}] {item['id']}".ljust(70) + "║")
|
|
|
|
print("║" + " DELETED".ljust(70) + "║")
|
|
for item in ops['deleted']:
|
|
print("║" + f" - [{item['type']}] {item['id']}".ljust(70) + "║")
|
|
|
|
print("╠" + "═" * 70 + "╣")
|
|
s = changelog['summary']
|
|
print("║" + " SUMMARY".ljust(70) + "║")
|
|
print("║" + f" Entities: +{s['entities_created']} ~{s['entities_updated']} -{s['entities_deleted']}".ljust(70) + "║")
|
|
print("║" + f" Files: +{s['files_created']} ~{s['files_updated']} -{s['files_deleted']}".ljust(70) + "║")
|
|
print("╚" + "═" * 70 + "╝")
|
|
|
|
|
|
def show_current():
|
|
"""Show current active workflow."""
|
|
session = load_current_session()
|
|
if not session:
|
|
print("No active workflow.")
|
|
print("Start one with: /workflow:spawn 'feature name'")
|
|
return
|
|
|
|
print()
|
|
print("╔" + "═" * 70 + "╗")
|
|
print("║" + "CURRENT WORKFLOW SESSION".center(70) + "║")
|
|
print("╠" + "═" * 70 + "╣")
|
|
print("║" + f" Version: {session['version']}".ljust(70) + "║")
|
|
print("║" + f" Feature: {session['feature'][:55]}".ljust(70) + "║")
|
|
print("║" + f" Phase: {session['current_phase']}".ljust(70) + "║")
|
|
print("║" + f" Status: {session['status']}".ljust(70) + "║")
|
|
print("╠" + "═" * 70 + "╣")
|
|
print("║" + " APPROVALS".ljust(70) + "║")
|
|
d = session['approvals']['design']
|
|
i = session['approvals']['implementation']
|
|
d_icon = "✅" if d['status'] == 'approved' else "❌" if d['status'] == 'rejected' else "⏳"
|
|
i_icon = "✅" if i['status'] == 'approved' else "❌" if i['status'] == 'rejected' else "⏳"
|
|
print("║" + f" {d_icon} Design: {d['status']}".ljust(70) + "║")
|
|
print("║" + f" {i_icon} Implementation: {i['status']}".ljust(70) + "║")
|
|
print("╠" + "═" * 70 + "╣")
|
|
s = session['summary']
|
|
print("║" + " PROGRESS".ljust(70) + "║")
|
|
print("║" + f" Tasks: {s['tasks_completed']}/{s['total_tasks']} completed".ljust(70) + "║")
|
|
print("║" + f" Entities: +{s['entities_created']} ~{s['entities_updated']} -{s['entities_deleted']}".ljust(70) + "║")
|
|
print("║" + f" Files: +{s['files_created']} ~{s['files_updated']} -{s['files_deleted']}".ljust(70) + "║")
|
|
print("╚" + "═" * 70 + "╝")
|
|
|
|
|
|
# ============================================================================
|
|
# CLI Interface
|
|
# ============================================================================
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="Workflow versioning system")
|
|
subparsers = parser.add_subparsers(dest='command', help='Commands')
|
|
|
|
# create command
|
|
create_parser = subparsers.add_parser('create', help='Create new workflow version')
|
|
create_parser.add_argument('feature', help='Feature description')
|
|
create_parser.add_argument('--parent', help='Parent version (for fixes)')
|
|
|
|
# current command
|
|
subparsers.add_parser('current', help='Show current workflow')
|
|
|
|
# history command
|
|
subparsers.add_parser('history', help='Show version history')
|
|
|
|
# changelog command
|
|
changelog_parser = subparsers.add_parser('changelog', help='Show version changelog')
|
|
changelog_parser.add_argument('version', help='Version to show')
|
|
|
|
# diff command
|
|
diff_parser = subparsers.add_parser('diff', help='Compare two versions')
|
|
diff_parser.add_argument('version1', help='First version')
|
|
diff_parser.add_argument('version2', help='Second version')
|
|
|
|
# task-start command
|
|
task_start = subparsers.add_parser('task-start', help='Start a task session')
|
|
task_start.add_argument('task_id', help='Task ID')
|
|
task_start.add_argument('--type', default='create', help='Task type')
|
|
task_start.add_argument('--agent', required=True, help='Agent performing task')
|
|
|
|
# task-complete command
|
|
task_complete = subparsers.add_parser('task-complete', help='Complete a task session')
|
|
task_complete.add_argument('task_id', help='Task ID')
|
|
task_complete.add_argument('--status', default='completed', help='Final status')
|
|
|
|
# log-op command
|
|
log_op = subparsers.add_parser('log-op', help='Log an operation')
|
|
log_op.add_argument('task_id', help='Task ID')
|
|
log_op.add_argument('op_type', choices=['CREATE', 'UPDATE', 'DELETE'])
|
|
log_op.add_argument('target_type', choices=['file', 'entity', 'task', 'manifest'])
|
|
log_op.add_argument('target_id', help='Target ID')
|
|
log_op.add_argument('--path', help='File path if applicable')
|
|
log_op.add_argument('--summary', help='Change summary')
|
|
|
|
# complete command
|
|
subparsers.add_parser('complete', help='Complete current workflow')
|
|
|
|
# update-phase command
|
|
phase_parser = subparsers.add_parser('update-phase', help='Update workflow phase')
|
|
phase_parser.add_argument('phase', help='New phase')
|
|
|
|
# tasks-dir command
|
|
tasks_dir_parser = subparsers.add_parser('tasks-dir', help='Get tasks directory for current or specific version')
|
|
tasks_dir_parser.add_argument('--version', help='Specific version (defaults to current)')
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.command == 'create':
|
|
session = create_workflow_session(args.feature, args.parent)
|
|
print(f"Created workflow version: {session['version']}")
|
|
print(f"Feature: {args.feature}")
|
|
print(f"Session ID: {session['session_id']}")
|
|
|
|
elif args.command == 'current':
|
|
show_current()
|
|
|
|
elif args.command == 'history':
|
|
show_history()
|
|
|
|
elif args.command == 'changelog':
|
|
show_changelog(args.version)
|
|
|
|
elif args.command == 'diff':
|
|
result = diff_versions(args.version1, args.version2)
|
|
if result:
|
|
print(json.dumps(result, indent=2))
|
|
else:
|
|
print("Could not compare versions")
|
|
|
|
elif args.command == 'task-start':
|
|
session = load_current_session()
|
|
if not session:
|
|
print("Error: No active workflow")
|
|
sys.exit(1)
|
|
task = create_task_session(session, args.task_id, args.type, args.agent)
|
|
print(f"Started task session: {task['session_id']}")
|
|
|
|
elif args.command == 'task-complete':
|
|
session = load_current_session()
|
|
if not session:
|
|
print("Error: No active workflow")
|
|
sys.exit(1)
|
|
task = load_task_session(session['version'], args.task_id)
|
|
if task:
|
|
complete_task_session(task, args.status)
|
|
print(f"Completed task: {args.task_id}")
|
|
else:
|
|
print(f"Task session not found: {args.task_id}")
|
|
|
|
elif args.command == 'log-op':
|
|
session = load_current_session()
|
|
if not session:
|
|
print("Error: No active workflow")
|
|
sys.exit(1)
|
|
task = load_task_session(session['version'], args.task_id)
|
|
if task:
|
|
op = log_operation(
|
|
task,
|
|
args.op_type,
|
|
args.target_type,
|
|
args.target_id,
|
|
target_path=args.path,
|
|
diff_summary=args.summary
|
|
)
|
|
print(f"Logged operation: {op['id']}")
|
|
else:
|
|
print(f"Task session not found: {args.task_id}")
|
|
|
|
elif args.command == 'complete':
|
|
session = load_current_session()
|
|
if not session:
|
|
print("Error: No active workflow")
|
|
sys.exit(1)
|
|
complete_workflow_session(session)
|
|
print(f"Completed workflow: {session['version']}")
|
|
|
|
elif args.command == 'update-phase':
|
|
session = load_current_session()
|
|
if not session:
|
|
print("Error: No active workflow")
|
|
sys.exit(1)
|
|
session['current_phase'] = args.phase
|
|
save_current_session(session)
|
|
print(f"Updated phase to: {args.phase}")
|
|
|
|
elif args.command == 'tasks-dir':
|
|
if args.version:
|
|
# Specific version requested
|
|
tasks_dir = get_version_tasks_dir(args.version)
|
|
tasks_dir.mkdir(parents=True, exist_ok=True)
|
|
print(str(tasks_dir))
|
|
else:
|
|
# Use current version
|
|
tasks_dir = get_current_tasks_dir()
|
|
if tasks_dir:
|
|
print(str(tasks_dir))
|
|
else:
|
|
print("Error: No active workflow")
|
|
sys.exit(1)
|
|
|
|
else:
|
|
parser.print_help()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|