sourcebot 0.1.0__py3-none-any.whl

sourcebot/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "0.1.0"
+__name__ = """                                 _           _   
+                                | |         | |  
+  ___  ___  _   _ _ __ ___ ___  | |__   ___ | |_ 
+ / __|/ _ \| | | | '__/ __/ _ \ | '_ \ / _ \| __|
+ \__ \ (_) | |_| | | | (_|  __/ | |_) | (_) | |_ 
+ |___/\___/ \__,_|_|  \___\___| |_.__/ \___/ \__|
+                                                 
+                                                 """

sourcebot/__main__.py

@@ -0,0 +1,17 @@
+# src/sourcebot/__main__.py
+import sys
+from sourcebot.cli.main import app
+from sourcebot.logging import setup_logging
+
+
+def main():
+    """Entry point for console script"""
+    setup_logging()
+    try:
+        app()
+    except KeyboardInterrupt:
+        print("\n👋 Bye")
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()

sourcebot/bus/__init__.py

@@ -0,0 +1,4 @@
+from sourcebot.bus.message_models import InboundMessage, OutboundMessage
+from sourcebot.bus.event_bus import EventBus
+
+__all__ = ["EventBus", "InboundMessage", "OutboundMessage"]

sourcebot/bus/channel_adapter.py

@@ -0,0 +1,21 @@
+# sourcebot/bus/channel_adapter.py
+from .message_models from OutboundMessage, InboundMessage
+from .event_bus from EventBus
+from typing import Any
+from abc import ABC, abstractmethod
+
+class ChannelAdapter(ABC):
+    def __init__(self, bus: EventBus):
+        self.bus = bus
+
+    @abstractmethod
+    async def start(self):
+        pass
+
+    @abstractmethod
+    async def send(self, msg: OutboundMessage):
+        pass
+
+    @abstractmethod
+    def normalize(self, raw_event: Any) -> InboundMessage:
+        pass

sourcebot/bus/event_bus.py

@@ -0,0 +1,15 @@
+# sourcebot/bus/event_bus.py
+import asyncio
+from typing import Any, Callable, Dict, List, Type, Coroutine
+from collections import defaultdict
+
+class EventBus:
+    def __init__(self):
+        self.handlers: Dict[Type, List[Callable[[Any], Coroutine]]] = defaultdict(list)
+
+    def subscribe(self, event_type: Type, handler: Callable[[Any], Coroutine]):
+        self.handlers[event_type].append(handler)
+
+    async def publish(self, event: Any):
+        if type(event) in self.handlers:
+            await asyncio.gather(*(h(event) for h in self.handlers[type(event)]))

sourcebot/bus/message_models.py

@@ -0,0 +1,33 @@
+# sourcebot/bus/message_models.py
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+@dataclass
+class InboundMessage:
+    channel: str
+    sender_id: str
+    conversation_id: str
+    content: str
+    message_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    timestamp: datetime = field(default_factory=datetime.utcnow)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    correlation_id: Optional[str] = None
+    type: str = "text"
+
+    @property
+    def session_key(self) -> str:
+        return f"{self.channel}:{self.conversation_id}:{self.sender_id}"
+
+
+@dataclass
+class OutboundMessage:
+    channel: str
+    conversation_id: str
+    content: str
+    message_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    reply_to: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    correlation_id: Optional[str] = None
+    type: str = "text"

sourcebot/bus/outbound_dispatcher.py

@@ -0,0 +1,15 @@
+# sourcebot/bus/outbound_dispatcher.py
+from .message_models from OutboundMessage
+from .channel_adapter from ChannelAdapter
+from typing import Dict
+
+class OutboundDispatcher:
+    def __init__(self, adapters: Dict[str, ChannelAdapter]):
+        self.adapters = adapters
+
+    async def dispatch(self, msg: OutboundMessage):
+        adapter = self.adapters.get(msg.channel)
+        if not adapter:
+            print(f"[WARN] No adapter for channel {msg.channel}")
+            return
+        await adapter.send(msg)

sourcebot/bus/session_manager.py

@@ -0,0 +1,20 @@
+# sourcebot/bus/session_manager.py
+from datetime import datetime
+from typing import Any, Dict
+
+class SessionManager:
+    def __init__(self):
+        self.sessions: Dict[str, Dict[str, Any]] = {}
+
+    def get(self, session_key: str) -> Dict[str, Any]:
+        if session_key not in self.sessions:
+            self.sessions[session_key] = {
+                "created_at": datetime.utcnow(),
+                "state": {},
+                "history": []
+            }
+        return self.sessions[session_key]
+
+    def append_history(self, session_key: str, message: InboundMessage):
+        session = self.get(session_key)
+        session["history"].append(message)

sourcebot/cli/commands/core/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.cli.commands.core.command_line import command_line
+
+__all__ = ["command_line"]

sourcebot/cli/commands/core/command_line.py

@@ -0,0 +1,26 @@
+# sourcebot/cli/commands/core/command_line.py
+from sourcebot.cli.commands.run_commands import CommandLineTool
+from sourcebot.runtime import InitSystem
+from datetime import datetime
+import logging
+logger = logging.getLogger(__name__)
+
+
+async def command_line():
+    
+    init_system = InitSystem()
+    console = init_system.console
+
+    command_line_tool = CommandLineTool(
+        console = console,
+        docker_sandbox = init_system.docker_sandbox,
+        dag_planner = init_system.dag_planner,
+        dag_scheduler = init_system.dag_scheduler,
+        conversation_service = init_system.conversation_service
+    )
+    try:
+        from sourcebot.cli.commands.run_commands import SafeRunner
+        runner = SafeRunner(command_line_tool)
+        await runner.run()
+    except EOFError:
+        console.print("\nGoodbye!")

sourcebot/cli/commands/init_commands/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.cli.commands.init_commands.init_global_config import init_global_config
+from sourcebot.cli.commands.init_commands.init_workspace_config import init_workspace_config
+__all__ = ["init_global_config", "init_workspace_config"]

sourcebot/cli/commands/init_commands/init_global_config.py

@@ -0,0 +1,30 @@
+# sourcebot/cli/commands/init_global_config.py 
+from sourcebot.config import ConfigManager
+from rich.console import Console
+from rich.prompt import Confirm
+console = Console()
+
+def init_global_config():
+
+
+    config_manager = ConfigManager()
+    global_config_path = config_manager.global_config_path
+  
+
+    if global_config_path.exists():
+        
+
+        console.print(f"[yellow]Config already exists at {global_config_path}[/yellow]")
+        console.print("  [bold]y[/bold] = overwrite with defaults (existing values will be lost)")
+        console.print("  [bold]N[/bold] = refresh config, keeping existing values and adding new fields")
+
+        confirm = Confirm.ask("[bold]Execute?[/bold]", default=True)
+
+        if confirm:
+            config_manager.init_global_config(True)
+            console.print(f"[green]✓[/green] Config reset to defaults at {global_config_path}")
+        else:
+            console.print(f"[green]✓[/green] Config refreshed at {global_config_path} (existing values preserved)")
+    else:
+        config_manager.init_global_config()
+        console.print(f"[green]✓[/green] Created config at {global_config_path}")

sourcebot/cli/commands/init_commands/init_workspace_config.py

@@ -0,0 +1,18 @@
+from sourcebot.config import ConfigManager
+from rich.console import Console
+from pathlib import Path
+
+def init_workspace_config():
+    console = Console()
+    config_manager = ConfigManager()
+    project_path = Path.cwd()
+    project_name = project_path.name
+    
+    if config_manager.load_workspace_config():
+        current_configuration = config_manager.find_workspace_config()
+        console.print(f"[yellow]Workspace config already exists at {current_configuration}[/yellow]")
+    else: 
+        config_manager.init_workspace_config(
+            project_name = project_name,
+            project_path = project_path
+        )

sourcebot/cli/commands/run_commands/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.cli.commands.run_commands.command_line_tool import CommandLineTool
+from sourcebot.cli.commands.run_commands.safe_runner import SafeRunner
+__all__ = ["command_line", "CommandLineTool"]

sourcebot/cli/commands/run_commands/command_line_tool.py

@@ -0,0 +1,345 @@
+# sourcebot/cli/commands/command_line_tool.py
+import asyncio
+import shlex
+from typing import Dict, Any, Optional, List
+from dataclasses import dataclass
+from enum import Enum
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.prompt import Confirm
+from rich import print as rprint
+from rich.markdown import Markdown
+import cmd2
+from sourcebot.bus import InboundMessage
+from sourcebot import __name__
+class CommandType(Enum):
+    SHELL = "shell"       # Shell commands
+    PYTHON = "python"     # Python code execution
+    SYSTEM = "system"     # System commands
+
+@dataclass
+class Command:
+    """Command data class"""
+    type: CommandType
+    name: str
+    content: str
+    args: Optional[Dict[str, Any]] = None
+    
+class CommandLineTool:
+    """Command line branching tool main class"""
+    
+    def __init__(
+        self,
+        console,
+        docker_sandbox,
+        dag_scheduler,
+        dag_planner,
+        conversation_service  
+        ):
+        self.console = console
+        self.docker_sandbox = docker_sandbox
+        self.dag_planner = dag_planner  
+        self.dag_scheduler = dag_scheduler
+        
+        self.command_history = []
+        self.last_plan_tasks = None  # Store recently generated plans
+        self.conversation_service = conversation_service
+        self._running = True
+
+    async def run(self):
+        try:
+            await self._startup()
+            await self._loop()
+        except Exception as e:
+            self.console.print(f"[red]Fatal: {e}[/red]")
+        finally:
+            await self._shutdown()
+
+    async def _startup(self):
+        await self.docker_sandbox.start()
+        self.console.print(Panel.fit(
+            f"{__name__}\n\n"
+            "[bold cyan]AI Assistant Command Line Interface[/bold cyan]\n"
+            "Type [bold]help[/bold] for available commands\n"
+            "Type [bold]exit[/bold] or [bold]quit[/bold] to exit\n"
+            "\n"
+            "[dim]• Chat mode: Just type anything[/dim]\n"
+            "[dim]• Tasks: [bold]task <description>[/bold][/dim]\n"
+            "[dim]• Commands: [bold]shell|python|system <command>[/bold][/dim]",
+            title="Welcome",
+            border_style="blue"
+        ))
+
+    async def _shutdown(self):
+        await self._cleanup()
+
+    async def _loop(self):
+        while self._running:
+            try:
+                user_input = await self._read_input()
+                if not user_input:
+                    continue
+                result = await self._process_command(user_input)
+                if result == "exit":
+                    self._running = False
+            except KeyboardInterrupt:
+                self.console.print("\n[yellow]Interrupted[/yellow]")
+                break
+            except Exception as e:
+                self.console.print(f"[red]Error: {e}[/red]")
+
+    async def _read_input(self):
+        try:
+            text = self.console.input("[bold blue]>>> [/bold blue]")
+        except (EOFError, KeyboardInterrupt):
+            return "exit"
+        return text.strip()
+
+    async def _process_command(self, user_input: str):
+        """Processing user input commands"""
+
+        parts = shlex.split(user_input)
+        cmd = parts[0].lower()
+        args = parts[1:] if len(parts) > 1 else []
+        # Command distribution 
+        if cmd == "help": 
+            self._show_help()
+        elif cmd in {"exit", "quit"}:
+            self.console.print("[yellow]Goodbye![/yellow]")
+            return "exit"
+        elif cmd == "shell": 
+            await self._handle_shell_command(args)
+        elif cmd == "python": 
+            await self._handle_python_command(args)
+        elif cmd == "system": 
+            await self._handle_system_command(args)
+        elif cmd == "task": 
+            await self._plan_and_confirm(' '.join(args))
+        elif cmd == "resume_run": 
+            await self._handle_resume_run(run_id = args[0])
+        elif cmd == "replay_failed": 
+            await self._handle_replay_failed(run_id = args[0])
+        elif cmd == "clear": 
+            self._handle_clear_command()
+        elif cmd == "history": 
+            self._show_history()
+        else:
+            await self._chat(user_input)
+    async def _chat(self, user_input: str):
+        msg = InboundMessage(
+            channel = "cli", 
+            sender_id = "user", 
+            conversation_id = "main", 
+            content = user_input
+            )
+        response = await self.conversation_service.handle_message(msg)
+        content = Markdown(response.content)
+        self.console.print()
+        self.console.print(content)
+        self.console.print()
+
+
+    async def _plan_and_confirm(self, user_input: str):
+        """
+        Planning-Confirmation-Execution Process
+        This is the core function of a planned task.
+        """
+        # 1. Generate plan
+        self.console.print("[bold cyan]📝 Generating execution plan...[/bold cyan]")
+        plan = await self.dag_planner.plan(user_input)
+        plan_tasks = plan["tasks"]
+        
+        if not plan_tasks:
+            self.console.print("[red]❌ Could not generate a plan for your input[/red]")
+            return
+            
+        self.last_plan_tasks = plan_tasks
+        
+        # 2. Display plan
+        self.console.print("\n[bold]Generated Plan:[/bold]")
+        self.console.print(self.last_plan_tasks)
+        # 3. Request user confirmation
+        self.console.print("\n[yellow]Do you want to execute this plan?[/yellow]")
+        confirm = Confirm.ask("[bold]Execute?[/bold]", default=True)
+        
+        if confirm:
+            # 4. Execute after user confirmation
+            self.console.print("[green]✓ Plan confirmed, starting execution...[/green]")
+            await self._execute_plan(plan_tasks)
+        else:
+            # 5. The user has not confirmed; modifications can be made before execution.
+            self.console.print("[yellow]⏸️ Plan execution cancelled[/yellow]")
+            run_id, run_dir = self.dag_scheduler.save_dag(plan_tasks)
+            self.console.print("[cyan]run_id[/cyan]:", run_id)
+            self.console.print("[cyan]run_dir[cyan]:", run_dir)
+            self.console.print("You can:")
+            self.console.print("Modify the task plan in  [cyan]dag.json[/cyan]")
+            self.console.print(f"Then restart the task with [cyan]resume_run {run_id}[/cyan]")
+ 
+    
+    async def _execute_plan(self, plan_tasks):
+        """Execute planned tasks"""
+        result = await self.dag_scheduler.run(plan_tasks)
+        self.console.print("[bold green]✅ Plan execution completed![/bold green]")
+
+
+
+    async def _handle_resume_run(self, run_id):
+        self.console.print("[bold green]Plan resume run start![/bold green]")
+        await self.dag_scheduler.resume(run_id = run_id)
+        self.console.print("[bold green]✅ Plan resume run completed![/bold green]")
+
+    async def _handle_replay_failed(self, run_id):
+        self.console.print("[bold green]✅ Plan replay failed start![/bold green]")
+        await self.dag_scheduler.replay_failed(run_id = run_id)
+        self.console.print("[bold green]✅ Plan replay failed completed![/bold green]")
+
+    async def _handle_shell_command(self, args: List[str]):
+        """Processing Shell commands"""
+        if not args:
+            self.console.print("[red]Usage: shell <command>[/red]")
+            return
+            
+        command = " ".join(args)
+        cmd = Command(
+            type=CommandType.SHELL,
+            name=f"shell_{len(self.command_history)}",
+            content=command
+        )
+        await self._execute_command(cmd)
+        
+    async def _handle_python_command(self, args: List[str]):
+        """Processing Python commands"""
+        if not args:
+            self.console.print("[red]Usage: python <code>[/red]")
+            self.console.print("       python -m <module>")
+            self.console.print("       python -f <file>")
+            return
+            
+        if args[0] == "-m":
+            if len(args) < 2:
+                self.console.print("[red]Usage: python -m <module>[/red]")
+                return
+            content = f"import {args[1]}"
+        elif args[0] == "-f":
+            if len(args) < 2:
+                self.console.print("[red]Usage: python -f <file>[/red]")
+                return
+            try:
+                with open(args[1], 'r') as f:
+                    content = f.read()
+            except FileNotFoundError:
+                self.console.print(f"[red]File not found: {args[1]}[/red]")
+                return
+        else:
+
+            content = " ".join(args)
+            
+        cmd = Command(
+            type=CommandType.PYTHON,
+            name=f"python_{len(self.command_history)}",
+            content=content
+        )
+        await self._execute_command(cmd)
+        
+    async def _handle_system_command(self, args: List[str]):
+        """Processing system commands"""
+        if not args:
+            self.console.print("[red]Usage: system <command>[/red]")
+            return
+            
+        command = " ".join(args)
+        cmd = Command(
+            type=CommandType.SYSTEM,
+            name=f"system_{len(self.command_history)}",
+            content=command
+        )
+        await self._execute_command(cmd)
+        
+        
+    def _handle_clear_command(self):
+        """clear screen"""
+        self.console.clear()
+        
+    def _show_history(self):
+        """Show command history"""
+        if not self.command_history:
+            self.console.print("[yellow]No command history[/yellow]")
+            return
+            
+        table = Table(title="Command History")
+        table.add_column("#", style="cyan")
+        table.add_column("Command", style="green")
+        
+        start = max(0, len(self.command_history) - 10)
+        for i in range(start, len(self.command_history)):
+            table.add_row(str(i + 1), self.command_history[i])
+            
+        self.console.print(table)
+        
+            
+    def _show_help(self):
+        """Display help information"""
+        help_text = """
+    [bold cyan]Available Commands:[/bold cyan]
+
+    [bold]Basic Commands:[/bold]
+    [green]help[/green]                    - Show this help message
+    [green]exit[/green] / [green]quit[/green]            - Exit the tool
+    [green]clear[/green]                   - Clear screen
+    [green]history[/green]                 - Show command history
+
+    [bold]Execution Commands:[/bold]
+    [green]shell <command>[/green]         - Execute shell command (non-blocking)
+    [green]python <code>[/green]           - Execute Python code
+    [green]system <command>[/green]        - Execute system command (blocking)
+    [green]<any text>[/green]              - Chat mode (default behavior)
+
+    [bold]Task Planning:[/bold]
+    [green]task <description>[/green]      - Generate and execute a plan for the task
+    [green]resume_run <run_id>[/green]     - Resume execution of a specific task run
+    [green]replay_failed <run_id>[/green]  - Replay failed tasks from a specific run
+
+    [bold]Workflow Example:[/bold]
+    [cyan]>>> task create a backup of all .txt files[/cyan]
+    [dim]# System generates plan and executes it automatically[/dim]
+    [cyan]>>> replay_failed run_123[/cyan]
+    [dim]# Replays only the failed tasks from run_123[/dim]
+        """
+        self.console.print(Panel(help_text, title="Help", border_style="blue"))
+        
+    async def _execute_command(self, command: Command):
+        """Execute commands in the sandbox"""
+        self.command_history.append(command.content)
+        
+        self.console.print(f"[cyan]Executing: {command.name}[/cyan]")
+        self.console.print(f"[dim]Command: {command.content}[/dim]")
+        
+        try:
+            result = await self.docker_sandbox.execute(command.content)
+            
+
+            if result:
+                self.console.print("[bold green]Output:[/bold green]")
+                
+                lines = result.split('\n')
+                for line in lines:
+                    if line.strip():  
+                        self.console.print(f"  [white]{line}[/white]")
+                    else:
+                        self.console.print("")  
+            else:
+                self.console.print("[yellow]Command executed successfully (no output)[/yellow]")
+                
+        except Exception as e:
+            self.console.print(f"[red]Error executing command: {str(e)}[/red]")
+    async def _cleanup(self):
+        """Clean up resources"""
+        try:
+            await self.docker_sandbox.stop()
+        except:
+            pass
+
+  

sourcebot/cli/commands/run_commands/safe_runner.py

@@ -0,0 +1,47 @@
+# sourcebot/cli/commands/safe_runner.py
+import inspect
+import asyncio
+
+class SafeRunner:
+    def __init__(self, obj):
+        self.obj = obj
+
+        # case 1: async function
+        if inspect.iscoroutinefunction(obj):
+            self.mode = "async_function"
+            return
+
+        # case 2: coroutine
+        if inspect.iscoroutine(obj):
+            self.mode = "coroutine"
+            return
+
+        # case 3: factory function 
+        if callable(obj) and not inspect.isclass(obj):
+            obj = obj()
+
+        self.obj = obj
+
+        # case 4: class instance with run()
+        if hasattr(self.obj, "run") and callable(self.obj.run):
+            self.mode = "runner"
+            self.is_async = inspect.iscoroutinefunction(self.obj.run)
+            return
+
+        raise TypeError(f"{type(obj)} is not runnable")
+
+    async def run(self, *args, **kwargs):
+        # async function
+        if self.mode == "async_function":
+            return await self.obj(*args, **kwargs)
+
+        # coroutine
+        if self.mode == "coroutine":
+            return await self.obj
+
+        # class with run()
+        if self.mode == "runner":
+            if self.is_async:
+                return await self.obj.run(*args, **kwargs)
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(None, lambda: self.obj.run(*args, **kwargs))

sourcebot/cli/main.py

@@ -0,0 +1,28 @@
+# src/sourcebot/cli/main.py
+import typer
+import sys
+
+app = typer.Typer(
+    name = "sourcebot",
+    no_args_is_help = True,
+    add_completion = False
+)
+@app.command("init")
+def init():
+    """Init global config"""
+    from sourcebot.cli.commands.init_commands import init_global_config
+    init_global_config()
+@app.command("init_workspace")  
+def agent():
+    """Init workspace config"""
+    from sourcebot.cli.commands.init_commands import init_workspace_config
+    init_workspace_config()
+@app.command("cli")  
+def test_init_agent_system():
+    """Start SourceBot AI Assistant CLI"""
+    from sourcebot.cli.commands.run_commands import SafeRunner
+    from sourcebot.cli.commands.core import command_line
+    import asyncio
+    runner = SafeRunner(command_line)
+    asyncio.run(runner.run())
+

sourcebot/config/__init__.py

@@ -0,0 +1,15 @@
+from .config_manager import ConfigManager
+from .global_config import GlobalConfig
+from .workspace_config import WorkspaceConfig, ModelConfig
+from .provider_config import ProviderConfig, ProvidersConfig
+from .exceptions import ConfigError
+
+__all__ = [
+    'ConfigManager',
+    'GlobalConfig',
+    'WorkspaceConfig',
+    'ModelConfig',
+    'ProviderConfig',
+    'ProvidersConfig',
+    'ConfigError',
+]