scitex 2.13.0__py3-none-any.whl → 2.15.1__py3-none-any.whl

scitex/template/_mcp_handlers.py

@@ -1,259 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2026-01-08
-# File: src/scitex/template/_mcp_handlers.py
-# ----------------------------------------
-
-"""
-MCP Handler implementations for SciTeX Template module.
-
-Provides async handlers for project scaffolding operations:
-- list_templates_handler: List available templates
-- get_template_info_handler: Get template details
-- clone_template_handler: Create project from template
-- list_git_strategies_handler: List git strategies
-"""
-
-from __future__ import annotations
-
-import asyncio
-from pathlib import Path
-from typing import Optional
-
-
-async def list_templates_handler() -> dict:
-    """
-    List all available SciTeX project templates.
-
-    Returns
-    -------
-    dict
-        Success status and list of templates with basic info
-    """
-    try:
-        from scitex.template import get_available_templates_info
-
-        templates = get_available_templates_info()
-
-        # Simplify for listing
-        template_list = [
-            {
-                "id": t["id"],
-                "name": t["name"],
-                "description": t["description"],
-                "use_case": t["use_case"],
-            }
-            for t in templates
-        ]
-
-        return {
-            "success": True,
-            "count": len(template_list),
-            "templates": template_list,
-        }
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e),
-        }
-
-
-async def get_template_info_handler(template_id: str) -> dict:
-    """
-    Get detailed information about a specific template.
-
-    Parameters
-    ----------
-    template_id : str
-        Template identifier (research, pip_project, singularity, paper_directory)
-
-    Returns
-    -------
-    dict
-        Success status and template details
-    """
-    try:
-        from scitex.template import get_available_templates_info
-
-        templates = get_available_templates_info()
-
-        # Find the requested template
-        template = None
-        for t in templates:
-            if t["id"] == template_id:
-                template = t
-                break
-
-        if template is None:
-            return {
-                "success": False,
-                "error": f"Template not found: {template_id}",
-                "available_templates": [t["id"] for t in templates],
-            }
-
-        return {
-            "success": True,
-            "template": template,
-        }
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e),
-        }
-
-
-async def clone_template_handler(
-    template_id: str,
-    project_name: str,
-    target_dir: Optional[str] = None,
-    git_strategy: str = "child",
-    branch: Optional[str] = None,
-    tag: Optional[str] = None,
-) -> dict:
-    """
-    Create a new project by cloning a template.
-
-    Parameters
-    ----------
-    template_id : str
-        Template to clone (research, pip_project, singularity, paper_directory)
-    project_name : str
-        Name for the new project
-    target_dir : str, optional
-        Parent directory for the project (default: current directory)
-    git_strategy : str, optional
-        Git initialization strategy (child, parent, origin, none)
-    branch : str, optional
-        Specific branch to clone
-    tag : str, optional
-        Specific tag to clone
-
-    Returns
-    -------
-    dict
-        Success status and project path
-    """
-    try:
-        # Map template_id to clone function
-        clone_functions = {
-            "research": "clone_research",
-            "pip_project": "clone_pip_project",
-            "singularity": "clone_singularity",
-            "paper_directory": "clone_writer_directory",
-        }
-
-        if template_id not in clone_functions:
-            return {
-                "success": False,
-                "error": f"Unknown template: {template_id}",
-                "available_templates": list(clone_functions.keys()),
-            }
-
-        # Import the specific clone function
-        import scitex.template as template_module
-
-        clone_func = getattr(template_module, clone_functions[template_id])
-
-        # Build project path
-        if target_dir:
-            project_path = str(Path(target_dir) / project_name)
-        else:
-            project_path = project_name
-
-        # Handle git_strategy='none'
-        git_strat = None if git_strategy == "none" else git_strategy
-
-        # Run clone in executor (blocking operation)
-        loop = asyncio.get_event_loop()
-        success = await loop.run_in_executor(
-            None,
-            lambda: clone_func(
-                project_dir=project_path,
-                git_strategy=git_strat,
-                branch=branch,
-                tag=tag,
-            ),
-        )
-
-        if success:
-            # Resolve the actual path
-            resolved_path = Path(project_path)
-            if not resolved_path.is_absolute():
-                resolved_path = Path.cwd() / resolved_path
-
-            return {
-                "success": True,
-                "project_path": str(resolved_path),
-                "template": template_id,
-                "git_strategy": git_strategy,
-                "message": f"Successfully created {template_id} project at {resolved_path}",
-            }
-        else:
-            return {
-                "success": False,
-                "error": f"Failed to clone template: {template_id}",
-                "project_name": project_name,
-            }
-
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e),
-        }
-
-
-async def list_git_strategies_handler() -> dict:
-    """
-    List available git initialization strategies.
-
-    Returns
-    -------
-    dict
-        Success status and list of strategies with descriptions
-    """
-    strategies = [
-        {
-            "id": "child",
-            "name": "Child Repository",
-            "description": "Create an isolated git repository in the project directory",
-            "recommended": True,
-            "preserves_template_history": False,
-        },
-        {
-            "id": "parent",
-            "name": "Parent Repository",
-            "description": "Use the parent directory's git repository (project becomes part of parent repo)",
-            "recommended": False,
-            "preserves_template_history": False,
-        },
-        {
-            "id": "origin",
-            "name": "Preserve Origin",
-            "description": "Keep the template's original git history (maintains connection to template repo)",
-            "recommended": False,
-            "preserves_template_history": True,
-        },
-        {
-            "id": "none",
-            "name": "No Git",
-            "description": "Skip git initialization entirely",
-            "recommended": False,
-            "preserves_template_history": False,
-        },
-    ]
-
-    return {
-        "success": True,
-        "count": len(strategies),
-        "strategies": strategies,
-        "default": "child",
-    }
-
-
-__all__ = [
-    "list_templates_handler",
-    "get_template_info_handler",
-    "clone_template_handler",
-    "list_git_strategies_handler",
-]
-
-# EOF

scitex/template/_mcp_tool_schemas.py

@@ -1,112 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2026-01-08
-# File: src/scitex/template/_mcp_tool_schemas.py
-# ----------------------------------------
-
-"""
-MCP Tool schemas for SciTeX Template module.
-
-Defines available tools for project scaffolding:
-- list_templates: List available project templates
-- get_template_info: Get detailed information about a template
-- clone_template: Create a new project from a template
-"""
-
-from __future__ import annotations
-
-import mcp.types as types
-
-
-def get_tool_schemas() -> list[types.Tool]:
-    """Return list of available MCP tools for template operations."""
-    return [
-        # List available templates
-        types.Tool(
-            name="list_templates",
-            description="List all available SciTeX project templates with their descriptions",
-            inputSchema={
-                "type": "object",
-                "properties": {},
-                "required": [],
-            },
-        ),
-        # Get template information
-        types.Tool(
-            name="get_template_info",
-            description="Get detailed information about a specific project template",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "template_id": {
-                        "type": "string",
-                        "description": "Template identifier (research, pip_project, singularity, paper_directory)",
-                        "enum": [
-                            "research",
-                            "pip_project",
-                            "singularity",
-                            "paper_directory",
-                        ],
-                    },
-                },
-                "required": ["template_id"],
-            },
-        ),
-        # Clone template
-        types.Tool(
-            name="clone_template",
-            description="Create a new project by cloning a template. Supports research projects, Python packages, Singularity containers, and paper directories.",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "template_id": {
-                        "type": "string",
-                        "description": "Template to clone (research, pip_project, singularity, paper_directory)",
-                        "enum": [
-                            "research",
-                            "pip_project",
-                            "singularity",
-                            "paper_directory",
-                        ],
-                    },
-                    "project_name": {
-                        "type": "string",
-                        "description": "Name for the new project (will be used as directory name)",
-                    },
-                    "target_dir": {
-                        "type": "string",
-                        "description": "Parent directory where project will be created (default: current directory)",
-                    },
-                    "git_strategy": {
-                        "type": "string",
-                        "description": "Git initialization strategy",
-                        "enum": ["child", "parent", "origin", "none"],
-                        "default": "child",
-                    },
-                    "branch": {
-                        "type": "string",
-                        "description": "Specific branch to clone (optional)",
-                    },
-                    "tag": {
-                        "type": "string",
-                        "description": "Specific tag/release to clone (optional)",
-                    },
-                },
-                "required": ["template_id", "project_name"],
-            },
-        ),
-        # Get git strategies
-        types.Tool(
-            name="list_git_strategies",
-            description="List available git initialization strategies for template cloning",
-            inputSchema={
-                "type": "object",
-                "properties": {},
-                "required": [],
-            },
-        ),
-    ]
-
-
-__all__ = ["get_tool_schemas"]
-
-# EOF

scitex/writer/.legacy/Writer_v01-refactored.py

@@ -1,189 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-10-29 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/Writer.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/Writer.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-"""
-Writer class for manuscript LaTeX compilation.
-
-Provides object-oriented interface to scitex-writer functionality.
-"""
-
-from pathlib import Path
-from typing import Optional, Callable
-
-from scitex.logging import getLogger
-
-# Delegate to specialized modules
-from ._project import ensure_project_exists, validate_structure, create_document_trees
-from ._git import initialize_git
-from ._compile import run_compile
-from .dataclasses import CompilationResult
-from .dataclasses.config import DOC_TYPE_DIRS
-from .utils._watch import watch_manuscript
-
-logger = getLogger(__name__)
-
-
-class Writer:
-    """
-    LaTeX manuscript compiler.
-
-    Simplified initialization that delegates to specialized modules.
-    """
-
-    def __init__(
-        self,
-        project_dir: Path,
-        name: Optional[str] = None,
-        git_strategy: Optional[str] = "child",
-    ):
-        """
-        Initialize for project directory.
-
-        If directory doesn't exist, creates new project.
-
-        Parameters
-        ----------
-        project_dir : Path
-            Path to project directory
-        name : str, optional
-            Project name (used if creating new project)
-        git_strategy : str or None
-            Git initialization strategy:
-            - 'child': Create isolated git in project directory (default)
-            - 'parent': Use parent git repository
-            - 'origin': Preserve template's original git history
-            - None: Disable git initialization
-        """
-        self.project_name = name or Path(project_dir).name
-        self.project_dir = Path(project_dir)
-        self.git_strategy = git_strategy
-
-        logger.info(
-            f"Writer: Initializing with:\n"
-            f"    Project Name: {self.project_name}\n"
-            f"    Project Directory: {self.project_dir.absolute()}\n"
-            f"    Git Strategy: {self.git_strategy}..."
-        )
-
-        # Delegate to specialized modules
-        self.project_dir = ensure_project_exists(
-            self.project_dir, self.project_name, self.git_strategy
-        )
-        validate_structure(self.project_dir)
-        self.git_root = initialize_git(self.project_dir, self.git_strategy)
-
-        # Create document trees
-        self.manuscript, self.supplementary, self.revision, self.scripts = (
-            create_document_trees(self.project_dir, self.git_root)
-        )
-
-        logger.success(f"Writer: Initialization complete for {self.project_name}")
-
-    def compile_manuscript(self, timeout: int = 300) -> CompilationResult:
-        """
-        Compile manuscript to PDF.
-
-        Runs scripts/shell/compile_manuscript.sh with configured settings.
-
-        Parameters
-        ----------
-        timeout : int
-            Maximum compilation time in seconds (default: 300)
-
-        Returns
-        -------
-        CompilationResult
-            Compilation status and outputs
-
-        Examples
-        --------
-        >>> writer = Writer(Path("my_paper"))
-        >>> result = writer.compile_manuscript()
-        >>> if result.success:
-        ...     print(f"PDF created: {result.output_pdf}")
-        """
-        return run_compile("manuscript", self.project_dir, timeout=timeout)
-
-    def compile_supplementary(self, timeout: int = 300) -> CompilationResult:
-        """
-        Compile supplementary materials to PDF.
-
-        Runs scripts/shell/compile_supplementary.sh with configured settings.
-
-        Parameters
-        ----------
-        timeout : int
-            Maximum compilation time in seconds (default: 300)
-
-        Returns
-        -------
-        CompilationResult
-            Compilation status and outputs
-        """
-        return run_compile("supplementary", self.project_dir, timeout=timeout)
-
-    def compile_revision(
-        self, track_changes: bool = False, timeout: int = 300
-    ) -> CompilationResult:
-        """
-        Compile revision document with optional change tracking.
-
-        Runs scripts/shell/compile_revision.sh with configured settings.
-
-        Parameters
-        ----------
-        track_changes : bool
-            Enable change tracking in compiled PDF (default: False)
-        timeout : int
-            Maximum compilation time in seconds (default: 300)
-
-        Returns
-        -------
-        CompilationResult
-            Compilation status and outputs
-        """
-        return run_compile(
-            "revision", self.project_dir, timeout=timeout, track_changes=track_changes
-        )
-
-    def watch(self, on_compile: Optional[Callable] = None) -> None:
-        """Auto-recompile on file changes."""
-        watch_manuscript(self.project_dir, on_compile=on_compile)
-
-    def get_pdf(self, doc_type: str = "manuscript") -> Optional[Path]:
-        """Get output PDF path."""
-        pdf = self.project_dir / DOC_TYPE_DIRS[doc_type] / f"{doc_type}.pdf"
-        return pdf if pdf.exists() else None
-
-    def delete(self) -> bool:
-        """Delete project directory."""
-        import shutil
-
-        try:
-            logger.warning(
-                f"Writer: Deleting project directory at {self.project_dir.absolute()}"
-            )
-            shutil.rmtree(self.project_dir)
-            logger.success(
-                f"Writer: Successfully deleted project at {self.project_dir.absolute()}"
-            )
-            return True
-        except Exception as e:
-            logger.error(
-                f"Writer: Failed to delete project directory at {self.project_dir.absolute()}: {e}"
-            )
-            return False
-
-
-__all__ = ["Writer"]
-
-# EOF