x-ipe 1.0.23__py3-none-any.whl → 1.0.25__py3-none-any.whl

x_ipe/routes/main_routes.py

@@ -15,17 +15,20 @@ from pathlib import Path
 from flask import Blueprint, render_template, jsonify, request, current_app, send_file
 
 from x_ipe.services import ProjectService, ContentService
+from x_ipe.tracing import x_ipe_tracing
 
 main_bp = Blueprint('main', __name__)
 
 
 @main_bp.route('/')
+@x_ipe_tracing()
 def index():
     """Serve main page with sidebar navigation"""
     return render_template('index.html')
 
 
 @main_bp.route('/uiux-feedbacks')
+@x_ipe_tracing()
 def uiux_feedbacks():
     """
     GET /uiux-feedbacks
@@ -36,6 +39,7 @@ def uiux_feedbacks():
 
 
 @main_bp.route('/workplace')
+@x_ipe_tracing()
 def workplace():
     """
     GET /workplace
@@ -46,7 +50,19 @@ def workplace():
     return render_template('workplace.html')
 
 
+@main_bp.route('/knowledge-base')
+@x_ipe_tracing()
+def knowledge_base():
+    """
+    GET /knowledge-base
+    
+    FEATURE-025-A: Knowledge Base page
+    """
+    return render_template('knowledge-base.html')
+
+
 @main_bp.route('/api/project/structure')
+@x_ipe_tracing()
 def get_project_structure():
     """
     GET /api/project/structure
@@ -68,6 +84,7 @@ def get_project_structure():
 
 
 @main_bp.route('/api/file/content')
+@x_ipe_tracing()
 def get_file_content():
     """
     GET /api/file/content?path=<relative_path>&raw=<true/false>
@@ -148,6 +165,7 @@ def get_file_content():
 
 
 @main_bp.route('/api/file/save', methods=['POST'])
+@x_ipe_tracing()
 def save_file():
     """
     POST /api/file/save

x_ipe/routes/project_routes.py

@@ -13,6 +13,8 @@ Provides:
 import os
 from flask import Blueprint, jsonify, request, current_app
 
+from x_ipe.tracing import x_ipe_tracing
+
 project_bp = Blueprint('project', __name__)
 
 
@@ -22,6 +24,7 @@ def get_project_folders_service():
 
 
 @project_bp.route('/api/projects', methods=['GET'])
+@x_ipe_tracing()
 def get_projects():
     """
     GET /api/projects
@@ -43,6 +46,7 @@ def get_projects():
 
 
 @project_bp.route('/api/projects', methods=['POST'])
+@x_ipe_tracing()
 def add_project():
     """
     POST /api/projects
@@ -78,6 +82,7 @@ def add_project():
 
 
 @project_bp.route('/api/projects/<int:project_id>', methods=['PUT'])
+@x_ipe_tracing()
 def update_project(project_id):
     """
     PUT /api/projects/<id>
@@ -113,6 +118,7 @@ def update_project(project_id):
 
 
 @project_bp.route('/api/projects/<int:project_id>', methods=['DELETE'])
+@x_ipe_tracing()
 def delete_project(project_id):
     """
     DELETE /api/projects/<id>
@@ -137,6 +143,7 @@ def delete_project(project_id):
 
 
 @project_bp.route('/api/projects/switch', methods=['POST'])
+@x_ipe_tracing()
 def switch_project():
     """
     POST /api/projects/switch

x_ipe/routes/proxy_routes.py

@@ -8,11 +8,13 @@ Provides localhost URL proxying endpoint.
 from flask import Blueprint, jsonify, request, Response
 
 from x_ipe.services import ProxyService
+from x_ipe.tracing import x_ipe_tracing
 
 proxy_bp = Blueprint('proxy', __name__)
 
 
 @proxy_bp.route('/api/proxy', methods=['GET'])
+@x_ipe_tracing()
 def proxy_url():
     """
     GET /api/proxy?url=<encoded_url>
@@ -46,15 +48,21 @@ def proxy_url():
     result = service.fetch_and_rewrite(url)
     
     if result.success:
+        # TASK-235: Handle binary content (fonts, images, etc.)
+        if result.binary_content is not None:
+            return Response(
+                result.binary_content,
+                mimetype=result.content_type.split(';')[0].strip()
+            )
         # For HTML, return JSON (used by frontend to set iframe.srcdoc)
-        if 'text/html' in result.content_type:
+        elif 'text/html' in result.content_type:
             return jsonify({
                 'success': True,
                 'html': result.html,
                 'content_type': result.content_type
             })
         else:
-            # For non-HTML (JS, CSS, images, etc.), return raw content
+            # For non-HTML text (JS, CSS, etc.), return raw content
             return Response(
                 result.html,  # Contains raw content for non-HTML
                 mimetype=result.content_type.split(';')[0].strip()

x_ipe/routes/quality_evaluation_routes.py

@@ -0,0 +1,193 @@
+"""
+FEATURE-024: Project Quality Evaluation UI
+
+API routes for quality evaluation file management.
+
+Provides REST endpoints for:
+- GET /api/quality-evaluation/status - Get folder status and versions
+- GET /api/quality-evaluation/content - Get markdown content for a version
+"""
+from flask import Blueprint, request, jsonify, current_app
+from pathlib import Path
+import re
+from datetime import datetime
+
+from x_ipe.tracing import x_ipe_tracing
+
+
+quality_evaluation_bp = Blueprint('quality_evaluation', __name__, url_prefix='/api/quality-evaluation')
+
+
+QUALITY_EVAL_FOLDER = 'x-ipe-docs/quality-evaluation'
+EVAL_FILE_PREFIX = 'project-quality-evaluation'
+
+
+def get_project_root() -> Path:
+    """Get project root from app config."""
+    return Path(current_app.config.get('PROJECT_ROOT', '.'))
+
+
+@x_ipe_tracing(level="INFO")
+def get_evaluation_folder() -> Path:
+    """Get the quality evaluation folder path."""
+    return get_project_root() / QUALITY_EVAL_FOLDER
+
+
+@x_ipe_tracing(level="INFO")
+def parse_version_from_filename(filename: str) -> str:
+    """Extract version number from filename.
+    
+    Examples:
+        project-quality-evaluation.md -> v5 (current)
+        project-quality-evaluation-v4.md -> v4
+    """
+    if filename == f'{EVAL_FILE_PREFIX}.md':
+        return 'current'
+    match = re.match(rf'{EVAL_FILE_PREFIX}-v(\d+)\.md', filename)
+    if match:
+        return f'v{match.group(1)}'
+    return None
+
+
+@x_ipe_tracing(level="INFO")
+def get_file_date(file_path: Path) -> str:
+    """Get formatted modification date for a file."""
+    try:
+        mtime = file_path.stat().st_mtime
+        dt = datetime.fromtimestamp(mtime)
+        return dt.strftime('%b %d')
+    except Exception:
+        return ''
+
+
+@x_ipe_tracing(level="INFO")
+def scan_versions(folder: Path) -> list:
+    """Scan folder for evaluation versions.
+    
+    Returns list of version dicts sorted by version number (newest first).
+    Latest (current) file is always first.
+    """
+    if not folder.exists():
+        return []
+    
+    versions = []
+    current_file = folder / f'{EVAL_FILE_PREFIX}.md'
+    
+    # Check for current (latest) file first
+    if current_file.exists():
+        # Count existing versioned files to determine current version number
+        versioned_files = list(folder.glob(f'{EVAL_FILE_PREFIX}-v*.md'))
+        max_version = 0
+        for vf in versioned_files:
+            match = re.match(rf'{EVAL_FILE_PREFIX}-v(\d+)\.md', vf.name)
+            if match:
+                max_version = max(max_version, int(match.group(1)))
+        
+        current_version = max_version + 1
+        versions.append({
+            'version': f'v{current_version}',
+            'filename': current_file.name,
+            'date': get_file_date(current_file),
+            'is_current': True
+        })
+    
+    # Scan for versioned files
+    versioned_files = sorted(
+        folder.glob(f'{EVAL_FILE_PREFIX}-v*.md'),
+        key=lambda f: int(re.search(r'-v(\d+)\.md', f.name).group(1)),
+        reverse=True
+    )
+    
+    for vf in versioned_files:
+        match = re.match(rf'{EVAL_FILE_PREFIX}-v(\d+)\.md', vf.name)
+        if match:
+            versions.append({
+                'version': f'v{match.group(1)}',
+                'filename': vf.name,
+                'date': get_file_date(vf),
+                'is_current': False
+            })
+    
+    # Limit to 5 most recent versions
+    return versions[:5]
+
+
+@quality_evaluation_bp.route('/status', methods=['GET'])
+@x_ipe_tracing(level="INFO")
+def get_status():
+    """
+    GET /api/quality-evaluation/status
+    
+    Get folder status and available versions.
+    
+    Response:
+        {
+            "exists": true,
+            "folder_path": "x-ipe-docs/quality-evaluation",
+            "versions": [
+                {"version": "v5", "filename": "project-quality-evaluation.md", "date": "Feb 1", "is_current": true},
+                {"version": "v4", "filename": "project-quality-evaluation-v4.md", "date": "Jan 31", "is_current": false}
+            ]
+        }
+    """
+    folder = get_evaluation_folder()
+    versions = scan_versions(folder)
+    
+    return jsonify({
+        'exists': len(versions) > 0,
+        'folder_path': QUALITY_EVAL_FOLDER,
+        'versions': versions
+    })
+
+
+@quality_evaluation_bp.route('/content', methods=['GET'])
+@x_ipe_tracing(level="INFO")
+def get_content():
+    """
+    GET /api/quality-evaluation/content
+    
+    Get markdown content for a specific version.
+    
+    Query Parameters:
+        version (optional): Version to retrieve (e.g., "v4"). Default: latest.
+    
+    Response:
+        {
+            "content": "# Project Quality Evaluation...",
+            "version": "v5",
+            "filename": "project-quality-evaluation.md",
+            "path": "x-ipe-docs/quality-evaluation/project-quality-evaluation.md"
+        }
+    """
+    folder = get_evaluation_folder()
+    requested_version = request.args.get('version')
+    
+    versions = scan_versions(folder)
+    if not versions:
+        return jsonify({'error': 'No evaluation file found'}), 404
+    
+    # Find the requested version or use latest
+    target_version = None
+    if requested_version:
+        for v in versions:
+            if v['version'] == requested_version:
+                target_version = v
+                break
+        if not target_version:
+            return jsonify({'error': f'Version {requested_version} not found'}), 404
+    else:
+        target_version = versions[0]  # Latest
+    
+    # Read the file content
+    file_path = folder / target_version['filename']
+    try:
+        content = file_path.read_text(encoding='utf-8')
+    except Exception as e:
+        return jsonify({'error': f'Failed to read file: {str(e)}'}), 500
+    
+    return jsonify({
+        'content': content,
+        'version': target_version['version'],
+        'filename': target_version['filename'],
+        'path': f"{QUALITY_EVAL_FOLDER}/{target_version['filename']}"
+    })

x_ipe/routes/settings_routes.py

@@ -12,6 +12,8 @@ Provides:
 import os
 from flask import Blueprint, render_template, jsonify, request, current_app
 
+from x_ipe.tracing import x_ipe_tracing
+
 settings_bp = Blueprint('settings', __name__)
 
 
@@ -21,6 +23,7 @@ def get_settings_service():
 
 
 @settings_bp.route('/settings')
+@x_ipe_tracing()
 def settings_page():
     """
     GET /settings
@@ -33,6 +36,7 @@ def settings_page():
 
 
 @settings_bp.route('/api/settings', methods=['GET'])
+@x_ipe_tracing()
 def get_settings():
     """
     GET /api/settings
@@ -50,6 +54,7 @@ def get_settings():
 
 
 @settings_bp.route('/api/settings', methods=['POST'])
+@x_ipe_tracing()
 def save_settings():
     """
     POST /api/settings
@@ -96,6 +101,7 @@ def save_settings():
 
 
 @settings_bp.route('/api/config', methods=['GET'])
+@x_ipe_tracing()
 def get_config():
     """
     GET /api/config

x_ipe/routes/tools_routes.py

@@ -14,6 +14,7 @@ import json
 from flask import Blueprint, jsonify, request, current_app
 
 from x_ipe.services import ToolsConfigService, ThemesService
+from x_ipe.tracing import x_ipe_tracing
 
 tools_bp = Blueprint('tools', __name__)
 
@@ -31,6 +32,7 @@ def _get_themes_service():
 
 
 @tools_bp.route('/api/config/tools', methods=['GET'])
+@x_ipe_tracing()
 def get_tools_config():
     """
     GET /api/config/tools
@@ -56,6 +58,7 @@ def get_tools_config():
 
 
 @tools_bp.route('/api/config/tools', methods=['POST'])
+@x_ipe_tracing()
 def save_tools_config():
     """
     POST /api/config/tools
@@ -93,6 +96,7 @@ def save_tools_config():
 
 
 @tools_bp.route('/api/config/copilot-prompt', methods=['GET'])
+@x_ipe_tracing()
 def get_copilot_prompt_config():
     """
     GET /api/config/copilot-prompt
@@ -130,6 +134,7 @@ def get_copilot_prompt_config():
 # ============================================================
 
 @tools_bp.route('/api/themes', methods=['GET'])
+@x_ipe_tracing()
 def list_themes():
     """
     GET /api/themes
@@ -163,6 +168,7 @@ def list_themes():
 
 
 @tools_bp.route('/api/themes/<name>', methods=['GET'])
+@x_ipe_tracing()
 def get_theme_detail(name):
     """
     GET /api/themes/<name>

x_ipe/routes/tracing_routes.py

@@ -0,0 +1,232 @@
+"""
+FEATURE-023: Application Action Tracing - Core
+
+Tracing API routes for controlling tracing and viewing logs.
+
+Provides REST endpoints for:
+- GET /api/tracing/status - Get tracing configuration
+- POST /api/tracing/start - Start tracing for duration
+- POST /api/tracing/stop - Stop tracing immediately
+- GET /api/tracing/logs - List trace log files
+- DELETE /api/tracing/logs - Delete all trace logs
+"""
+from flask import Blueprint, request, jsonify, current_app
+from pathlib import Path
+
+from x_ipe.services.tracing_service import TracingService
+from x_ipe.tracing import x_ipe_tracing
+
+
+tracing_bp = Blueprint('tracing', __name__, url_prefix='/api/tracing')
+
+
+def get_service() -> TracingService:
+    """Get TracingService instance for current app."""
+    project_root = current_app.config.get('PROJECT_ROOT', '.')
+    return TracingService(project_root)
+
+
+@tracing_bp.route('/status', methods=['GET'])
+@x_ipe_tracing()
+def get_status():
+    """
+    GET /api/tracing/status
+    
+    Get current tracing configuration and status.
+    
+    Response:
+        {
+            "enabled": false,
+            "stop_at": "2026-02-01T03:30:00Z",
+            "log_path": "instance/traces/",
+            "retention_hours": 24,
+            "ignored_apis": [],
+            "active": true
+        }
+    """
+    service = get_service()
+    config = service.get_config()
+    config["active"] = service.is_active()
+    return jsonify(config)
+
+
+@tracing_bp.route('/start', methods=['POST'])
+@x_ipe_tracing()
+def start_tracing():
+    """
+    POST /api/tracing/start
+    
+    Start tracing for specified duration.
+    
+    Request:
+        {
+            "duration_minutes": 3 | 15 | 30
+        }
+    
+    Response:
+        {
+            "success": true,
+            "stop_at": "2026-02-01T03:33:00Z"
+        }
+    
+    Errors:
+        400 - Invalid duration (must be 3, 15, or 30)
+    """
+    data = request.get_json() or {}
+    duration = data.get('duration_minutes', 3)
+    
+    try:
+        service = get_service()
+        result = service.start(duration)
+        return jsonify(result)
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 400
+
+
+@tracing_bp.route('/stop', methods=['POST'])
+@x_ipe_tracing()
+def stop_tracing():
+    """
+    POST /api/tracing/stop
+    
+    Stop tracing immediately.
+    
+    Response:
+        {
+            "success": true
+        }
+    """
+    service = get_service()
+    result = service.stop()
+    return jsonify(result)
+
+
+@tracing_bp.route('/logs', methods=['GET'])
+@x_ipe_tracing()
+def list_logs():
+    """
+    GET /api/tracing/logs
+    
+    List all trace log files.
+    
+    Response:
+        [
+            {
+                "trace_id": "abc-123",
+                "filename": "20260201-033000-post-api-orders-abc-123.log",
+                "size": 1234,
+                "timestamp": "2026-02-01T03:30:00"
+            }
+        ]
+    """
+    service = get_service()
+    logs = service.list_logs()
+    return jsonify(logs)
+
+
+@tracing_bp.route('/logs', methods=['DELETE'])
+@x_ipe_tracing()
+def delete_logs():
+    """
+    DELETE /api/tracing/logs
+    
+    Delete all trace log files.
+    
+    Response:
+        {
+            "deleted": 5
+        }
+    """
+    service = get_service()
+    deleted = service.delete_all_logs()
+    return jsonify({"deleted": deleted})
+
+
+@tracing_bp.route('/logs/<trace_id>', methods=['GET'])
+@x_ipe_tracing()
+def get_trace(trace_id):
+    """
+    GET /api/tracing/logs/<trace_id>
+    
+    Get parsed trace data for DAG visualization.
+    
+    Response:
+        {
+            "trace_id": "abc-123",
+            "api": "POST /api/orders",
+            "timestamp": "2026-02-01T03:30:00",
+            "total_time_ms": 245,
+            "status": "success",
+            "nodes": [
+                {
+                    "id": "node-0",
+                    "label": "POST /api/orders",
+                    "timing": "245ms",
+                    "status": "success",
+                    "level": "API",
+                    "input": "{}",
+                    "output": "{}",
+                    "error": null
+                }
+            ],
+            "edges": [
+                {"source": "node-0", "target": "node-1"}
+            ],
+            "filename": "20260201-post-api-orders-abc123.log"
+        }
+        
+    Errors:
+        404 - Trace not found
+    """
+    service = get_service()
+    result = service.get_trace(trace_id)
+    
+    if result is None:
+        return jsonify({"error": f"Trace not found: {trace_id}"}), 404
+    
+    return jsonify(result)
+
+
+@tracing_bp.route('/ignored', methods=['GET'])
+@x_ipe_tracing()
+def get_ignored_apis():
+    """
+    GET /api/tracing/ignored
+    
+    Get list of ignored API patterns.
+    
+    Response:
+        {
+            "patterns": ["/api/health/*", "/api/status"]
+        }
+    """
+    service = get_service()
+    config = service.get_config()
+    return jsonify({"patterns": config.get("ignored_apis", [])})
+
+
+@tracing_bp.route('/ignored', methods=['POST'])
+@x_ipe_tracing()
+def update_ignored_apis():
+    """
+    POST /api/tracing/ignored
+    
+    Update list of ignored API patterns.
+    
+    Request:
+        {
+            "patterns": ["/api/health/*", "/api/status"]
+        }
+    
+    Response:
+        {
+            "success": true
+        }
+    """
+    data = request.get_json() or {}
+    patterns = data.get('patterns', [])
+    
+    service = get_service()
+    service.update_ignored_apis(patterns)
+    
+    return jsonify({"success": True})