monoco-toolkit 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

monoco/core/artifacts/models.py

@@ -0,0 +1,161 @@
+"""
+Artifact data models for Monoco Artifact System.
+
+Defines the metadata structure, enums, and data classes for artifact management.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class ArtifactSourceType(str, Enum):
+    """Source type of the artifact."""
+
+    GENERATED = "generated"  # AI-generated content
+    UPLOADED = "uploaded"  # User-uploaded file
+    IMPORTED = "imported"  # Imported from external source
+    DERIVED = "derived"  # Derived from another artifact
+
+
+class ArtifactStatus(str, Enum):
+    """Lifecycle status of the artifact."""
+
+    ACTIVE = "active"
+    ARCHIVED = "archived"
+    EXPIRED = "expired"
+    DELETED = "deleted"
+
+
+class ArtifactMetadata(BaseModel):
+    """
+    Metadata record for an artifact in the manifest.
+
+    Each artifact is uniquely identified by its content hash (SHA256).
+    The manifest.jsonl contains one JSON line per artifact metadata.
+    """
+
+    artifact_id: str = Field(
+        description="Unique identifier (ULID or UUID) for the artifact instance"
+    )
+    content_hash: str = Field(
+        description="SHA256 hash of the artifact content (CAS address)"
+    )
+    source_type: ArtifactSourceType = Field(description="How the artifact was created")
+    status: ArtifactStatus = Field(
+        default=ArtifactStatus.ACTIVE, description="Current lifecycle status"
+    )
+    created_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), description="Creation timestamp (UTC)"
+    )
+    updated_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), description="Last update timestamp (UTC)"
+    )
+    expires_at: Optional[datetime] = Field(
+        default=None, description="Optional expiration timestamp"
+    )
+    content_type: str = Field(
+        default="application/octet-stream", description="MIME type of the content"
+    )
+    size_bytes: int = Field(default=0, description="Size of the artifact in bytes")
+    original_filename: Optional[str] = Field(
+        default=None, description="Original filename if uploaded"
+    )
+    source_url: Optional[str] = Field(
+        default=None, description="Source URL if imported from external"
+    )
+    parent_artifact_id: Optional[str] = Field(
+        default=None, description="Parent artifact ID if this is derived"
+    )
+    tags: list[str] = Field(default_factory=list, description="User-defined tags")
+    metadata: dict[str, Any] = Field(
+        default_factory=dict, description="Additional metadata key-value pairs"
+    )
+
+    @field_validator("content_hash")
+    @classmethod
+    def validate_content_hash(cls, v: str) -> str:
+        """Validate that content_hash is a valid SHA256 hex string."""
+        if len(v) != 64:
+            raise ValueError("content_hash must be a 64-character SHA256 hex string")
+        try:
+            int(v, 16)
+        except ValueError:
+            raise ValueError("content_hash must be a valid hex string")
+        return v
+
+    def to_jsonl_line(self) -> str:
+        """Serialize to a single JSON line for manifest.jsonl."""
+        return json.dumps(self.model_dump(mode="json"), ensure_ascii=False) + "\n"
+
+    @classmethod
+    def from_jsonl_line(cls, line: str) -> ArtifactMetadata:
+        """Deserialize from a JSON line."""
+        data = json.loads(line.strip())
+        return cls.model_validate(data)
+
+    @property
+    def is_expired(self) -> bool:
+        """Check if the artifact has expired."""
+        if self.expires_at is None:
+            return False
+        return datetime.now(timezone.utc) > self.expires_at
+
+    @property
+    def cas_path_components(self) -> tuple[str, str, str]:
+        """
+        Generate CAS storage path components from content_hash.
+
+        Returns (prefix1, prefix2, filename) for tiered directory structure.
+        Example: hash='abc123...' -> ('ab', 'c1', 'abc123...')
+        """
+        if len(self.content_hash) < 4:
+            raise ValueError("content_hash too short for path generation")
+        return (
+            self.content_hash[:2],
+            self.content_hash[2:4],
+            self.content_hash,
+        )
+
+    @property
+    def cas_relative_path(self) -> str:
+        """Get the relative CAS path for this artifact."""
+        p1, p2, filename = self.cas_path_components
+        return f"{p1}/{p2}/{filename}"
+
+
+def compute_content_hash(content: bytes) -> str:
+    """
+    Compute SHA256 hash of content for CAS addressing.
+
+    Args:
+        content: Raw bytes of the artifact content
+
+    Returns:
+        64-character lowercase hex string of the SHA256 hash
+    """
+    return hashlib.sha256(content).hexdigest()
+
+
+def compute_file_hash(file_path: Path) -> str:
+    """
+    Compute SHA256 hash of a file for CAS addressing.
+
+    Args:
+        file_path: Path to the file to hash
+
+    Returns:
+        64-character lowercase hex string of the SHA256 hash
+    """
+    hasher = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            hasher.update(chunk)
+    return hasher.hexdigest()

monoco/core/config.py

@@ -72,6 +72,24 @@ class TelemetryConfig(BaseModel):
     )
 
 
+class HooksConfig(BaseModel):
+    """Configuration for git hooks management."""
+
+    enabled: bool = Field(default=True, description="Whether hooks system is enabled")
+    features: Dict[str, bool] = Field(
+        default_factory=dict,
+        description="Per-feature hook enable/disable (feature_name -> enabled)"
+    )
+    hooks: Dict[str, bool] = Field(
+        default_factory=lambda: {
+            "pre-commit": True,
+            "pre-push": False,
+            "post-checkout": False,
+        },
+        description="Per-hook-type enable/disable (hook_type -> enabled)"
+    )
+
+
 class IssueTypeConfig(BaseModel):
     name: str
     label: str
@@ -91,6 +109,7 @@ class TransitionConfig(BaseModel):
     required_solution: Optional[str] = None
     description: str = ""
     command_template: Optional[str] = None
+    post_actions: List[str] = Field(default_factory=list)
 
 
 class CriticalityRuleConfig(BaseModel):
@@ -135,6 +154,23 @@ class CriticalityConfig(BaseModel):
         return self
 
 
+class AgentConcurrencyConfig(BaseModel):
+    """Configuration for agent concurrency limits (semaphore-based)."""
+    global_max: int = Field(default=3, description="Global maximum concurrent agents across all roles")
+    engineer: int = Field(default=1, description="Maximum concurrent Engineer agents")
+    architect: int = Field(default=1, description="Maximum concurrent Architect agents")
+    reviewer: int = Field(default=1, description="Maximum concurrent Reviewer agents")
+    planner: int = Field(default=1, description="Maximum concurrent Planner agents")
+    # Cool-down configuration
+    failure_cooldown_seconds: int = Field(default=60, description="Cooldown period after a failure before retrying")
+
+
+class AgentConfig(BaseModel):
+    """Configuration for AI Agents."""
+    timeout_seconds: int = Field(default=900, description="Global timeout for agent sessions")
+    concurrency: AgentConcurrencyConfig = Field(default_factory=AgentConcurrencyConfig)
+
+
 class IssueSchemaConfig(BaseModel):
     types: List[IssueTypeConfig] = Field(default_factory=list)
     statuses: List[str] = Field(default_factory=list)
@@ -230,10 +266,7 @@ class MonocoConfig(BaseModel):
     i18n: I18nConfig = Field(default_factory=I18nConfig)
     ui: UIConfig = Field(default_factory=UIConfig)
     telemetry: TelemetryConfig = Field(default_factory=TelemetryConfig)
-    hooks: Dict[str, str] = Field(
-        default_factory=dict,
-        description="Git hooks configuration (hook_name -> command)",
-    )
+    hooks: HooksConfig = Field(default_factory=HooksConfig)
     session_hooks: Dict[str, Any] = Field(
         default_factory=dict,
         description="Session lifecycle hooks configuration (hook_name -> config)",
@@ -241,6 +274,7 @@ class MonocoConfig(BaseModel):
 
     issue: IssueSchemaConfig = Field(default_factory=IssueSchemaConfig)
     domains: DomainConfig = Field(default_factory=DomainConfig)
+    agent: AgentConfig = Field(default_factory=AgentConfig)
 
     @staticmethod
     def _deep_merge(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:

monoco/core/git.py

@@ -149,6 +149,29 @@ def delete_branch(path: Path, branch_name: str, force: bool = False):
         raise RuntimeError(f"Failed to delete branch {branch_name}: {stderr}")
 
 
+def get_merge_base(path: Path, ref1: str, ref2: str) -> str:
+    code, stdout, stderr = _run_git(["merge-base", ref1, ref2], path)
+    if code != 0:
+        raise RuntimeError(f"Failed to find merge base: {stderr}")
+    return stdout.strip()
+
+
+def git_checkout_files(path: Path, ref: str, files: List[str]):
+    if not files:
+        return
+    code, _, stderr = _run_git(["checkout", ref, "--"] + files, path)
+    if code != 0:
+        raise RuntimeError(f"Failed to checkout files from {ref}: {stderr}")
+
+
+def has_diff(path: Path, ref1: str, ref2: str, files: List[str]) -> bool:
+    """Check if there are differences between two refs for specific files."""
+    if not files:
+        return False
+    code, stdout, _ = _run_git(["diff", "--name-only", ref1, ref2, "--"] + files, path)
+    return code == 0 and bool(stdout.strip())
+
+
 def get_worktrees(path: Path) -> List[Tuple[str, str, str]]:
     """Returns list of (path, head, branch)"""
     code, stdout, stderr = _run_git(["worktree", "list", "--porcelain"], path)

monoco/core/hooks/builtin/git_cleanup.py

@@ -31,7 +31,7 @@ class GitCleanupHook(SessionLifecycleHook):
         
         # Configuration with defaults
         self.auto_switch_to_main = self.config.get("auto_switch_to_main", True)
-        self.auto_delete_merged_branches = self.config.get("auto_delete_merged_branches", True)
+        self.auto_delete_merged_branches = self.config.get("auto_delete_merged_branches", False)
         self.main_branch = self.config.get("main_branch", "main")
         self.require_clean_worktree = self.config.get("require_clean_worktree", True)
 

monoco/core/ingestion/__init__.py

@@ -0,0 +1,20 @@
+"""
+Monoco Mailroom - Automated Ingestion System
+
+Provides environment discovery, file watching, and automated conversion
+for document ingestion into the Monoco Artifact System.
+"""
+
+from .discovery import EnvironmentDiscovery, ConversionTool
+from .worker import ConversionWorker, ConversionTask, ConversionResult
+from .watcher import DropzoneWatcher, IngestionEvent
+
+__all__ = [
+    "EnvironmentDiscovery",
+    "ConversionTool",
+    "ConversionWorker",
+    "ConversionTask",
+    "ConversionResult",
+    "DropzoneWatcher",
+    "IngestionEvent",
+]

monoco/core/ingestion/discovery.py

@@ -0,0 +1,248 @@
+"""
+Environment Discovery Module for Monoco Mailroom.
+
+Automatically detects available document conversion tools in the system,
+including LibreOffice (soffice), Pandoc, and PDF processing engines.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+
+class ToolType(str, Enum):
+    """Types of conversion tools supported."""
+    LIBREOFFICE = "libreoffice"
+    PANDOC = "pandoc"
+    PDF2TEXT = "pdf2text"
+    PDFTOHTML = "pdftohtml"
+    CUSTOM = "custom"
+
+
+class ToolCapability(str, Enum):
+    """Capabilities of conversion tools."""
+    DOCX_TO_TEXT = "docx_to_text"
+    DOCX_TO_MD = "docx_to_md"
+    PDF_TO_TEXT = "pdf_to_text"
+    PDF_TO_HTML = "pdf_to_html"
+    ODT_TO_TEXT = "odt_to_text"
+    XLSX_TO_CSV = "xlsx_to_csv"
+    PPTX_TO_TEXT = "pptx_to_text"
+
+
+@dataclass
+class ConversionTool:
+    """Represents a discovered conversion tool."""
+    name: str
+    tool_type: ToolType
+    executable_path: Path
+    version: str = "unknown"
+    capabilities: list[ToolCapability] = field(default_factory=list)
+    priority: int = 0  # Higher = preferred
+
+    def is_available(self) -> bool:
+        """Check if the tool executable exists and is runnable."""
+        return self.executable_path.exists() and os.access(self.executable_path, os.X_OK)
+
+
+class EnvironmentDiscovery:
+    """
+    Discovers and manages document conversion tools in the system.
+    
+    Automatically detects:
+    - LibreOffice (soffice) for Office document conversion
+    - Pandoc for markdown/text conversion
+    - PDF utilities (pdftotext, pdftohtml)
+    """
+
+    # Known executable names to search for
+    LIBREOFFICE_BINARIES = ["soffice", "libreoffice", "soffice.bin"]
+    PANDOC_BINARIES = ["pandoc"]
+    PDF_TOOLS = ["pdftotext", "pdftohtml", "pdf2txt.py"]
+
+    def __init__(self):
+        self._tools: dict[ToolType, list[ConversionTool]] = {}
+        self._discovered = False
+
+    def discover(self, force: bool = False) -> dict[ToolType, list[ConversionTool]]:
+        """
+        Discover all available conversion tools.
+        
+        Args:
+            force: Force re-discovery even if already done
+            
+        Returns:
+            Dictionary mapping tool types to lists of discovered tools
+        """
+        if self._discovered and not force:
+            return self._tools
+
+        self._tools = {
+            ToolType.LIBREOFFICE: self._discover_libreoffice(),
+            ToolType.PANDOC: self._discover_pandoc(),
+            ToolType.PDF2TEXT: self._discover_pdf_tools(),
+        }
+        
+        self._discovered = True
+        return self._tools
+
+    def _find_executable(self, names: list[str]) -> Optional[Path]:
+        """Find the first available executable from a list of names."""
+        for name in names:
+            path = shutil.which(name)
+            if path:
+                return Path(path).resolve()
+        return None
+
+    def _get_version(self, executable: Path, version_arg: str = "--version") -> str:
+        """Get version string from an executable."""
+        try:
+            result = subprocess.run(
+                [str(executable), version_arg],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            # Extract version from first line of output
+            output = result.stdout or result.stderr
+            if output:
+                first_line = output.strip().split("\n")[0]
+                return first_line
+        except (subprocess.TimeoutExpired, OSError, ValueError):
+            pass
+        return "unknown"
+
+    def _discover_libreoffice(self) -> list[ConversionTool]:
+        """Discover LibreOffice installation."""
+        tools = []
+        executable = self._find_executable(self.LIBREOFFICE_BINARIES)
+        
+        if executable:
+            version = self._get_version(executable)
+            tools.append(ConversionTool(
+                name="LibreOffice",
+                tool_type=ToolType.LIBREOFFICE,
+                executable_path=executable,
+                version=version,
+                capabilities=[
+                    ToolCapability.DOCX_TO_TEXT,
+                    ToolCapability.DOCX_TO_MD,
+                    ToolCapability.ODT_TO_TEXT,
+                    ToolCapability.XLSX_TO_CSV,
+                    ToolCapability.PPTX_TO_TEXT,
+                ],
+                priority=100,  # High priority for Office docs
+            ))
+        
+        return tools
+
+    def _discover_pandoc(self) -> list[ConversionTool]:
+        """Discover Pandoc installation."""
+        tools = []
+        executable = self._find_executable(self.PANDOC_BINARIES)
+        
+        if executable:
+            version = self._get_version(executable)
+            tools.append(ConversionTool(
+                name="Pandoc",
+                tool_type=ToolType.PANDOC,
+                executable_path=executable,
+                version=version,
+                capabilities=[
+                    ToolCapability.DOCX_TO_MD,
+                    ToolCapability.DOCX_TO_TEXT,
+                    ToolCapability.ODT_TO_TEXT,
+                ],
+                priority=90,
+            ))
+        
+        return tools
+
+    def _discover_pdf_tools(self) -> list[ConversionTool]:
+        """Discover PDF conversion tools."""
+        tools = []
+        
+        # pdftotext (from poppler-utils)
+        pdftotext = self._find_executable(["pdftotext"])
+        if pdftotext:
+            version = self._get_version(pdftotext, "-v")
+            tools.append(ConversionTool(
+                name="pdftotext",
+                tool_type=ToolType.PDF2TEXT,
+                executable_path=pdftotext,
+                version=version,
+                capabilities=[ToolCapability.PDF_TO_TEXT],
+                priority=100,
+            ))
+        
+        # pdftohtml
+        pdftohtml = self._find_executable(["pdftohtml"])
+        if pdftohtml:
+            version = self._get_version(pdftohtml, "-v")
+            tools.append(ConversionTool(
+                name="pdftohtml",
+                tool_type=ToolType.PDFTOHTML,
+                executable_path=pdftohtml,
+                version=version,
+                capabilities=[ToolCapability.PDF_TO_HTML],
+                priority=80,
+            ))
+        
+        return tools
+
+    def get_best_tool(self, capability: ToolCapability) -> Optional[ConversionTool]:
+        """
+        Get the best available tool for a specific capability.
+        
+        Args:
+            capability: The required conversion capability
+            
+        Returns:
+            Best matching ConversionTool or None
+        """
+        if not self._discovered:
+            self.discover()
+
+        candidates = []
+        for tool_list in self._tools.values():
+            for tool in tool_list:
+                if capability in tool.capabilities:
+                    candidates.append(tool)
+
+        if not candidates:
+            return None
+
+        # Sort by priority (highest first)
+        candidates.sort(key=lambda t: t.priority, reverse=True)
+        return candidates[0]
+
+    def get_all_tools(self) -> list[ConversionTool]:
+        """Get all discovered tools."""
+        if not self._discovered:
+            self.discover()
+        
+        all_tools = []
+        for tool_list in self._tools.values():
+            all_tools.extend(tool_list)
+        return all_tools
+
+    def has_capability(self, capability: ToolCapability) -> bool:
+        """Check if any tool supports the given capability."""
+        return self.get_best_tool(capability) is not None
+
+    def get_capabilities_summary(self) -> dict[str, bool]:
+        """Get a summary of available capabilities."""
+        return {
+            cap.value: self.has_capability(cap)
+            for cap in ToolCapability
+        }
+
+
+# Import os here to avoid issues with dataclass
+import os