PraisonAI 3.0.0__py3-none-any.whl

praisonai/cli/schedule_cli.py

@@ -0,0 +1,54 @@
+"""
+Simple CLI entry point for praisonai schedule command.
+
+This provides a standalone entry point that can be called from main.py
+"""
+
+import sys
+from praisonai.cli.features.agent_scheduler import AgentSchedulerHandler
+
+
+def main():
+    """Main entry point for schedule CLI command."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description='Schedule an agent to run continuously at regular intervals'
+    )
+    
+    parser.add_argument(
+        'schedule_yaml',
+        nargs='?',
+        default='agents.yaml',
+        help='Path to agents.yaml file (default: agents.yaml)'
+    )
+    
+    parser.add_argument(
+        '--interval',
+        dest='schedule_interval',
+        type=str,
+        help='Override schedule interval (e.g., "hourly", "*/30m", "daily")'
+    )
+    
+    parser.add_argument(
+        '--max-retries',
+        dest='schedule_max_retries',
+        type=int,
+        help='Override maximum retry attempts (default: from YAML or 3)'
+    )
+    
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Enable verbose logging'
+    )
+    
+    args = parser.parse_args()
+    
+    # Call the handler
+    exit_code = AgentSchedulerHandler.handle_schedule_command(args)
+    sys.exit(exit_code)
+
+
+if __name__ == '__main__':
+    main()

praisonai/cli/state/__init__.py

@@ -0,0 +1,31 @@
+"""
+PraisonAI CLI State Module.
+
+Provides state management for run IDs, trace IDs, agent IDs, and sessions.
+"""
+
+from .identifiers import (
+    generate_run_id,
+    generate_trace_id,
+    generate_agent_id,
+    RunContext,
+    get_current_context,
+    set_current_context,
+)
+from .sessions import (
+    SessionManager,
+    SessionMetadata,
+    get_session_manager,
+)
+
+__all__ = [
+    'generate_run_id',
+    'generate_trace_id',
+    'generate_agent_id',
+    'RunContext',
+    'get_current_context',
+    'set_current_context',
+    'SessionManager',
+    'SessionMetadata',
+    'get_session_manager',
+]

praisonai/cli/state/identifiers.py

@@ -0,0 +1,161 @@
+"""
+Identifier generation for PraisonAI CLI.
+
+Provides stable, unique identifiers for runs, traces, and agents.
+"""
+
+import hashlib
+import os
+import secrets
+import threading
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, Optional
+
+
+def generate_run_id() -> str:
+    """
+    Generate a unique run ID.
+    
+    Format: run_YYYYMMDD_HHMMSS_<random>
+    Example: run_20241231_143022_a1b2c3
+    """
+    timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+    random_suffix = secrets.token_hex(3)  # 6 characters
+    return f"run_{timestamp}_{random_suffix}"
+
+
+def generate_trace_id() -> str:
+    """
+    Generate a unique trace ID.
+    
+    Format: trace_<random>
+    Example: trace_a1b2c3d4e5f6
+    """
+    return f"trace_{secrets.token_hex(6)}"
+
+
+def generate_agent_id(agent_name: str, run_id: str, index: int = 0) -> str:
+    """
+    Generate a deterministic agent ID.
+    
+    The ID is deterministic based on agent name, run ID, and index,
+    ensuring consistent IDs across the same run.
+    
+    Format: agent_<hash>_<index>
+    Example: agent_a1b2c3_001
+    
+    Args:
+        agent_name: Name of the agent
+        run_id: Current run ID
+        index: Agent index within the run
+        
+    Returns:
+        Deterministic agent ID
+    """
+    # Create deterministic hash from agent name and run ID
+    hash_input = f"{agent_name}:{run_id}:{index}"
+    hash_value = hashlib.sha256(hash_input.encode()).hexdigest()[:6]
+    return f"agent_{hash_value}_{index:03d}"
+
+
+@dataclass
+class RunContext:
+    """
+    Context for a single run.
+    
+    Holds all identifiers and metadata for the current execution.
+    """
+    run_id: str = field(default_factory=generate_run_id)
+    trace_id: str = field(default_factory=generate_trace_id)
+    start_time: datetime = field(default_factory=datetime.utcnow)
+    
+    # Agent tracking
+    agents: Dict[str, str] = field(default_factory=dict)  # name -> agent_id
+    _agent_counter: int = field(default=0, repr=False)
+    
+    # Metadata
+    config_summary: Dict[str, str] = field(default_factory=dict)
+    workspace: Optional[str] = None
+    
+    def get_agent_id(self, agent_name: str) -> str:
+        """
+        Get or create an agent ID for the given agent name.
+        
+        Args:
+            agent_name: Name of the agent
+            
+        Returns:
+            Agent ID (creates new one if not exists)
+        """
+        if agent_name not in self.agents:
+            agent_id = generate_agent_id(agent_name, self.run_id, self._agent_counter)
+            self.agents[agent_name] = agent_id
+            self._agent_counter += 1
+        return self.agents[agent_name]
+    
+    def to_dict(self) -> Dict:
+        """Convert to dictionary for serialization."""
+        return {
+            "run_id": self.run_id,
+            "trace_id": self.trace_id,
+            "start_time": self.start_time.isoformat(),
+            "agents": self.agents.copy(),
+            "config_summary": self.config_summary.copy(),
+            "workspace": self.workspace,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> "RunContext":
+        """Create from dictionary."""
+        ctx = cls(
+            run_id=data.get("run_id", generate_run_id()),
+            trace_id=data.get("trace_id", generate_trace_id()),
+            workspace=data.get("workspace"),
+        )
+        ctx.agents = data.get("agents", {})
+        ctx.config_summary = data.get("config_summary", {})
+        ctx._agent_counter = len(ctx.agents)
+        
+        start_time = data.get("start_time")
+        if start_time:
+            try:
+                ctx.start_time = datetime.fromisoformat(start_time)
+            except (ValueError, TypeError):
+                pass
+        
+        return ctx
+
+
+# Thread-local storage for current context
+_context_local = threading.local()
+
+
+def get_current_context() -> Optional[RunContext]:
+    """Get the current run context for this thread."""
+    return getattr(_context_local, "context", None)
+
+
+def set_current_context(context: Optional[RunContext]) -> None:
+    """Set the current run context for this thread."""
+    _context_local.context = context
+
+
+def create_context(workspace: Optional[str] = None) -> RunContext:
+    """
+    Create a new run context and set it as current.
+    
+    Args:
+        workspace: Optional workspace path
+        
+    Returns:
+        New RunContext instance
+    """
+    context = RunContext(workspace=workspace or os.getcwd())
+    set_current_context(context)
+    return context
+
+
+def clear_context() -> None:
+    """Clear the current run context."""
+    set_current_context(None)

praisonai/cli/state/sessions.py

@@ -0,0 +1,313 @@
+"""
+Session management for PraisonAI CLI.
+
+Provides persistence and resume functionality for sessions.
+"""
+
+import json
+import os
+import shutil
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..configuration.paths import get_sessions_dir, ensure_config_dirs
+from .identifiers import RunContext
+
+
+@dataclass
+class SessionMetadata:
+    """Metadata for a session."""
+    session_id: str
+    run_id: str
+    trace_id: str
+    created_at: datetime
+    updated_at: datetime
+    name: Optional[str] = None
+    workspace: Optional[str] = None
+    config_summary: Dict[str, Any] = field(default_factory=dict)
+    event_count: int = 0
+    status: str = "active"  # active, completed, error
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "session_id": self.session_id,
+            "run_id": self.run_id,
+            "trace_id": self.trace_id,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "name": self.name,
+            "workspace": self.workspace,
+            "config_summary": self.config_summary,
+            "event_count": self.event_count,
+            "status": self.status,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SessionMetadata":
+        """Create from dictionary."""
+        return cls(
+            session_id=data["session_id"],
+            run_id=data["run_id"],
+            trace_id=data["trace_id"],
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+            name=data.get("name"),
+            workspace=data.get("workspace"),
+            config_summary=data.get("config_summary", {}),
+            event_count=data.get("event_count", 0),
+            status=data.get("status", "active"),
+        )
+
+
+class SessionManager:
+    """
+    Manages session persistence and retrieval.
+    
+    Sessions are stored in ~/.praison/sessions/<session_id>/
+    Each session contains:
+    - metadata.json: Session metadata
+    - events.jsonl: Stream of events (NDJSON)
+    """
+    
+    def __init__(self, sessions_dir: Optional[Path] = None):
+        self.sessions_dir = sessions_dir or get_sessions_dir()
+        ensure_config_dirs()
+    
+    def _get_session_dir(self, session_id: str) -> Path:
+        """Get the directory for a session."""
+        return self.sessions_dir / session_id
+    
+    def _get_metadata_path(self, session_id: str) -> Path:
+        """Get the metadata file path for a session."""
+        return self._get_session_dir(session_id) / "metadata.json"
+    
+    def _get_events_path(self, session_id: str) -> Path:
+        """Get the events file path for a session."""
+        return self._get_session_dir(session_id) / "events.jsonl"
+    
+    def create(self, context: RunContext, name: Optional[str] = None) -> SessionMetadata:
+        """
+        Create a new session from a run context.
+        
+        Args:
+            context: Run context to create session from
+            name: Optional session name
+            
+        Returns:
+            Session metadata
+        """
+        session_id = context.run_id  # Use run_id as session_id
+        session_dir = self._get_session_dir(session_id)
+        session_dir.mkdir(parents=True, exist_ok=True)
+        
+        now = datetime.utcnow()
+        metadata = SessionMetadata(
+            session_id=session_id,
+            run_id=context.run_id,
+            trace_id=context.trace_id,
+            created_at=now,
+            updated_at=now,
+            name=name,
+            workspace=context.workspace,
+            config_summary=context.config_summary,
+        )
+        
+        # Save metadata
+        self._save_metadata(metadata)
+        
+        # Create empty events file
+        self._get_events_path(session_id).touch()
+        
+        return metadata
+    
+    def _save_metadata(self, metadata: SessionMetadata) -> None:
+        """Save session metadata."""
+        path = self._get_metadata_path(metadata.session_id)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(metadata.to_dict(), f, indent=2)
+    
+    def _load_metadata(self, session_id: str) -> Optional[SessionMetadata]:
+        """Load session metadata."""
+        path = self._get_metadata_path(session_id)
+        if not path.exists():
+            return None
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return SessionMetadata.from_dict(data)
+        except (json.JSONDecodeError, KeyError):
+            return None
+    
+    def append_event(self, session_id: str, event: Dict[str, Any]) -> None:
+        """
+        Append an event to a session.
+        
+        Args:
+            session_id: Session ID
+            event: Event data to append
+        """
+        events_path = self._get_events_path(session_id)
+        if not events_path.parent.exists():
+            return
+        
+        with open(events_path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(event, default=str) + "\n")
+        
+        # Update metadata
+        metadata = self._load_metadata(session_id)
+        if metadata:
+            metadata.event_count += 1
+            metadata.updated_at = datetime.utcnow()
+            self._save_metadata(metadata)
+    
+    def get(self, session_id: str) -> Optional[SessionMetadata]:
+        """Get session metadata by ID."""
+        return self._load_metadata(session_id)
+    
+    def list(self, limit: int = 50) -> List[SessionMetadata]:
+        """
+        List all sessions, sorted by updated_at descending.
+        
+        Args:
+            limit: Maximum number of sessions to return
+            
+        Returns:
+            List of session metadata
+        """
+        sessions = []
+        
+        if not self.sessions_dir.exists():
+            return sessions
+        
+        for session_dir in self.sessions_dir.iterdir():
+            if session_dir.is_dir():
+                metadata = self._load_metadata(session_dir.name)
+                if metadata:
+                    sessions.append(metadata)
+        
+        # Sort by updated_at descending
+        sessions.sort(key=lambda s: s.updated_at, reverse=True)
+        
+        return sessions[:limit]
+    
+    def delete(self, session_id: str) -> bool:
+        """
+        Delete a session.
+        
+        Args:
+            session_id: Session ID to delete
+            
+        Returns:
+            True if deleted, False if not found
+        """
+        session_dir = self._get_session_dir(session_id)
+        if not session_dir.exists():
+            return False
+        
+        shutil.rmtree(session_dir)
+        return True
+    
+    def get_events(self, session_id: str) -> List[Dict[str, Any]]:
+        """
+        Get all events for a session.
+        
+        Args:
+            session_id: Session ID
+            
+        Returns:
+            List of events
+        """
+        events_path = self._get_events_path(session_id)
+        if not events_path.exists():
+            return []
+        
+        events = []
+        with open(events_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    try:
+                        events.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        pass
+        
+        return events
+    
+    def export(self, session_id: str, format: str = "md") -> Optional[str]:
+        """
+        Export a session to a string.
+        
+        Args:
+            session_id: Session ID
+            format: Export format ("md" or "json")
+            
+        Returns:
+            Exported content or None if not found
+        """
+        metadata = self._load_metadata(session_id)
+        if not metadata:
+            return None
+        
+        events = self.get_events(session_id)
+        
+        if format == "json":
+            return json.dumps({
+                "metadata": metadata.to_dict(),
+                "events": events,
+            }, indent=2, default=str)
+        
+        # Markdown format
+        lines = [
+            f"# Session: {metadata.name or metadata.session_id}",
+            "",
+            f"- **Run ID**: {metadata.run_id}",
+            f"- **Trace ID**: {metadata.trace_id}",
+            f"- **Created**: {metadata.created_at.isoformat()}",
+            f"- **Status**: {metadata.status}",
+            "",
+            "## Events",
+            "",
+        ]
+        
+        for event in events:
+            event_type = event.get("event", "unknown")
+            timestamp = event.get("timestamp", "")
+            message = event.get("message", "")
+            
+            lines.append(f"### {event_type} ({timestamp})")
+            if message:
+                lines.append(f"\n{message}")
+            
+            data = event.get("data", {})
+            if data:
+                lines.append("\n```json")
+                lines.append(json.dumps(data, indent=2, default=str))
+                lines.append("```")
+            
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    def update_status(self, session_id: str, status: str) -> None:
+        """Update session status."""
+        metadata = self._load_metadata(session_id)
+        if metadata:
+            metadata.status = status
+            metadata.updated_at = datetime.utcnow()
+            self._save_metadata(metadata)
+
+
+# Global session manager
+_session_manager: Optional[SessionManager] = None
+
+
+def get_session_manager() -> SessionManager:
+    """Get the global session manager."""
+    global _session_manager
+    if _session_manager is None:
+        _session_manager = SessionManager()
+    return _session_manager

praisonai/code/__init__.py

@@ -0,0 +1,93 @@
+"""
+PraisonAI Code - AI-powered code editing tools.
+
+This module provides tools for AI agents to read, write, and modify code files
+with precision using search/replace diff strategies similar to Kilo Code.
+
+Features:
+- read_file: Read file contents with optional line ranges
+- write_file: Create or overwrite files
+- list_files: List directory contents with filtering
+- apply_diff: Apply SEARCH/REPLACE diffs with fuzzy matching
+- search_replace: Multiple search/replace operations
+- execute_command: Run shell commands safely
+
+Example:
+    from praisonai.code import read_file, write_file, apply_diff
+    
+    # Read a file
+    content = read_file("path/to/file.py")
+    
+    # Write a file
+    write_file("path/to/new_file.py", "print('hello')")
+    
+    # Apply a diff
+    result = apply_diff("path/to/file.py", diff_content)
+"""
+
+from .tools import (
+    read_file,
+    write_file,
+    list_files,
+    apply_diff,
+    search_replace,
+    execute_command,
+)
+
+from .diff import (
+    DiffResult,
+    apply_search_replace_diff,
+    parse_diff_blocks,
+)
+
+from .utils import (
+    FileAccessController,
+    add_line_numbers,
+    strip_line_numbers,
+)
+
+from .agent_tools import (
+    set_workspace,
+    get_workspace,
+    code_read_file,
+    code_write_file,
+    code_list_files,
+    code_apply_diff,
+    code_search_replace,
+    code_execute_command,
+    CODE_TOOLS,
+    create_diff_block,
+    create_multi_diff,
+)
+
+__all__ = [
+    # Main tools (low-level)
+    "read_file",
+    "write_file", 
+    "list_files",
+    "apply_diff",
+    "search_replace",
+    "execute_command",
+    # Agent tools (high-level, string returns)
+    "set_workspace",
+    "get_workspace",
+    "code_read_file",
+    "code_write_file",
+    "code_list_files",
+    "code_apply_diff",
+    "code_search_replace",
+    "code_execute_command",
+    "CODE_TOOLS",
+    "create_diff_block",
+    "create_multi_diff",
+    # Diff utilities
+    "DiffResult",
+    "apply_search_replace_diff",
+    "parse_diff_blocks",
+    # Utilities
+    "FileAccessController",
+    "add_line_numbers",
+    "strip_line_numbers",
+]
+
+__version__ = "0.1.0"