sourcebot 0.1.0__py3-none-any.whl

sourcebot/prompt/identity_prompt.py

@@ -0,0 +1,98 @@
+# sourcebot/prompt/identity_prompt.py
+IDENTITY_PROMPT = """
+
+You are **sourcebot**, an autonomous AI assistant capable of solving tasks using tools.
+
+---
+
+# Current Time
+
+{now} ({tz})
+
+---
+
+# Runtime
+
+{runtime}
+
+---
+
+# Workspace
+
+Your workspace is located at:
+
+{workspace_path}
+
+Important directories:
+
+Long-term memory  
+{workspace_path}/memory/MEMORY.md
+
+History log  
+{workspace_path}/memory/HISTORY.md
+
+Custom skills  
+{workspace_path}/skills/{{skill-name}}/SKILL.md
+
+---
+
+# Available Tools
+
+You have access to the following tools. When you need to use a tool, the system will handle the function calling format automatically.
+
+## shell
+Execute shell commands in the runtime environment.
+
+## skill_list
+Return to the skill list.Directly calling this tool will return to the skill catalog list
+
+## skill_detail
+Get the details corresponding to the skill name
+
+## rule_list
+Returns the list of available rules. Call this tool to see all rules that must be followed.
+
+## rule_detail
+Get detailed information about a specific rule. Provide the rule name to retrieve its full content and requirements.
+---
+
+# Execution Strategy
+
+When solving tasks:
+
+1. Understand the problem
+2. Use tools when necessary (the system will handle the function call format)
+3. Observe tool results
+4. Continue reasoning
+5. Repeat until the task is solved
+
+You may call tools multiple times.
+
+---
+
+# Memory
+
+When remembering something important, write to:
+
+{workspace_path}/memory/MEMORY.md
+
+To recall past events, search:
+
+{workspace_path}/memory/HISTORY.md
+
+---
+
+# Communication Rules
+
+When responding to normal user questions:
+
+Reply directly with text.
+
+Do NOT call tools unless necessary.
+
+---
+
+# Style
+
+Be helpful, accurate, and concise.
+"""

sourcebot/prompt/subagent_prompt.py

@@ -0,0 +1,25 @@
+# sourcebot/prompt/subagent_prompt.py
+SUBAGENT_PROMPT = """# Subagent
+    
+## Current Time
+{now} ({tz})
+
+You are a subagent spawned by the main agent to complete a specific task.
+
+## Rules
+1. Stay focused - complete only the assigned task, nothing else
+2. Your final response will be reported back to the main agent
+3. Do not initiate conversations or take on side tasks
+4. Be concise but informative in your findings
+
+## What You Can Do
+- Read and write files in the workspace
+- Execute shell commands
+- Complete the task thoroughly
+
+
+## Workspace
+Your workspace is at: {workspace}
+The skills currently assigned may not be sufficient for your current task. If necessary, please use the `skill_list` and `skill_detail` tools to obtain the optimal skills.
+
+When you have completed the task, provide a clear summary of your findings or actions."""

sourcebot/runtime/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.runtime.tool_executor import ToolExecutor
+from sourcebot.runtime.init_system import InitSystem
+__all__ = ["ToolExecutor", "InitSystem"]

sourcebot/runtime/agent/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.runtime.agent.agent import Agent
+from sourcebot.runtime.agent.agent_factory import AgentFactory
+__all__ = ["AgentFactory", "Agent"]

sourcebot/runtime/agent/agent.py

@@ -0,0 +1,130 @@
+# sourcebot/runtime/agent_runtime.py 
+import json
+from pathlib import Path
+from typing import List, Dict, Any, Callable, Optional
+import logging
+from sourcebot.security.policy import SecurityPolicy
+from sourcebot.tools.registry import ToolRegistry
+from sourcebot.context import MessageBuilder
+from sourcebot.utils import strip_think, parse_tool_args, ensure_string
+from datetime import datetime
+from sourcebot.runtime import ToolExecutor
+from sourcebot.bus import EventBus, OutboundMessage
+
+logger = logging.getLogger(__name__)
+class Agent:
+    """
+    A unified runtime environment for the main agent and sub-agents.
+    Supports:
+    - LLM loop
+    - Tool execution
+    - Policy hooks
+    - Message bus # TODO
+    """
+
+    def __init__(
+        self,
+        bus: EventBus,
+        llm,
+        tools: ToolRegistry,
+        message_builder: MessageBuilder,
+        policy: Optional[SecurityPolicy] = None,
+        task_id: Optional[str] = None,
+        task_description: Optional[str] = None,
+        max_tool_calls: int = 40,
+        max_iterations: int = 40,
+    ):
+        self.bus = bus
+        self.llm = llm
+        self.tools = tools
+        self.message_builder = message_builder
+        self.policy = policy
+        self.task_id = task_id
+        self.task_description = task_description
+        # Limits
+        self.max_tool_calls = max_tool_calls
+        self.max_iterations = max_iterations
+
+        self.tool_executor = ToolExecutor(
+            tools,
+            timeout = 60,
+            retries = 2
+        )
+
+
+    async def run(
+        self,
+        messages: List[Dict[str, Any]],
+        use_tools: bool = True,
+        use_policy: bool = True,
+    ):
+        """
+        agent loop
+        """
+        tools_used: list[str] = []
+        tool_counter = 0
+        logger.info(f"{self.task_id} Running")
+        for i in range(self.max_iterations):
+
+            # Policy before llm
+            if self.policy and use_policy:
+                await self.policy.before_llm(messages)
+
+            response = await self.llm.complete(
+                messages = messages,
+                tools = self.tools.get_definitions(),
+            )
+            # # Response adapter
+            llm_tool_calls = response.tool_calls
+
+            # Tool calls
+            if llm_tool_calls and use_tools:
+
+                messages = self.message_builder.add_assistant_message(
+                    messages = messages,
+                    content = response.content,
+                    tool_calls = llm_tool_calls,
+                )
+                for tool_call in llm_tool_calls:
+                    tool_name = tool_call.name
+
+                    tools_used.append(tool_name)
+
+                    tool_counter += 1
+                    if tool_counter > self.max_tool_calls:
+                        raise RuntimeError("Exceeded max tool calls")
+                    args = parse_tool_args(tool_call.arguments)
+
+                    # Policy before tool
+                    if self.policy and use_policy:
+                        await self.policy.before_tool(tool_name, args)
+
+                    result = await self.tool_executor.execute(
+                        tool_name,
+                        args
+                    )
+
+                    # Policy after tool
+                    if self.policy and use_policy:
+                        await self.policy.after_tool(
+                            tool_name,
+                            result,
+                        )
+
+                    messages = self.message_builder.add_tool_result(
+                        messages = messages,
+                        tool_call_id = tool_call.id,
+                        result = ensure_string(result), 
+                    )
+  
+            # Final response
+            else:
+                logger.info(f"{self.task_id} Completed")
+
+                final = strip_think(response.content)
+
+                return final, self.task_id, tools_used
+        
+        raise RuntimeError("Max iterations exceeded")
+
+

sourcebot/runtime/agent/agent_factory.py

@@ -0,0 +1,83 @@
+# sourcebot/runtime/agent/agent_factory.py
+from sourcebot.runtime.agent import Agent
+from typing import Optional
+from pathlib import Path
+from sourcebot.tools import ToolRegistry
+from sourcebot.llm import LLMClientFactory
+
+import logging
+logger = logging.getLogger(__name__)
+class AgentFactory:
+    """
+    Factory responsible for building Agent instances
+    for both main agent and subagents.
+    """
+
+    def __init__(
+        self,
+        bus,
+        message_builder,
+        policy,
+        main_provider_name,
+        main_model_name, 
+        config_manager,
+        max_tool_calls: int = 40,
+        max_iterations: int = 40,
+        sub_provider_name: Optional[str] = None,
+        sub_model_name: Optional[str] = None,
+        tools: Optional[ToolRegistry] = None,
+    ):
+        self.bus = bus
+        self.message_builder = message_builder
+        self.policy = policy
+        self.main_provider_name = main_provider_name
+        self.main_model_name = main_model_name
+        self.config_manager = config_manager
+        self.sub_provider_name = sub_provider_name
+        self.sub_model_name = sub_model_name
+        self.max_tool_calls = max_tool_calls
+        self.max_iterations = max_iterations
+        self.tools = tools
+        
+    def build_main_agent(self) -> Agent:
+        """
+        Build main agent.
+        """
+        llm = LLMClientFactory.create_client(
+            config_manager = self.config_manager,
+            provider_name = self.main_provider_name,
+            model_name = self.main_model_name
+        )
+        return Agent(
+            bus = self.bus,
+            llm = llm,
+            tools = self.tools,
+            message_builder = self.message_builder,
+            policy = self.policy,
+            max_tool_calls = self.max_tool_calls,
+            max_iterations = self.max_iterations,
+            task_id = "main_agent"
+        )
+
+    def build_sub_agent(self, task_id, task_description) -> Agent:
+        """
+        Build sub agent.
+        """
+        llm = LLMClientFactory.create_client(
+            config_manager = self.config_manager,
+            provider_name = self.sub_provider_name or self.main_provider_name,
+            model_name = self.sub_model_name or self.main_model_name
+        )
+        return Agent(
+            bus = self.bus,
+            tools = self.tools,
+            llm = llm,
+            message_builder = self.message_builder,
+            policy = self.policy,
+            task_id = task_id,
+            task_description = task_description,
+            max_tool_calls = self.max_tool_calls,
+            max_iterations = self.max_iterations,
+        )
+
+

sourcebot/runtime/dag/planner/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.runtime.dag.planner.dag_planner import DAGPlanner
+
+__all__ = ["DAGPlanner"]

sourcebot/runtime/dag/planner/dag_planner.py

@@ -0,0 +1,26 @@
+# sourcebot/planning/dag_planner.py
+
+import uuid
+from typing import List, Dict
+import logging
+from .task_decomposer import TaskDecomposer
+from .parallelism_optimizer import ParallelismOptimizer
+from .execution_scheduler import ExecutionScheduler
+
+logger = logging.getLogger(__name__)
+class DAGPlanner:
+
+    def __init__(self, llm, context_build):
+
+        self.decomposer = TaskDecomposer(llm, context_build)
+        self.optimizer = ParallelismOptimizer()
+        self.scheduler = ExecutionScheduler()
+
+    async def plan(self, query: str):
+        steps = await self.decomposer.decompose(query)
+        steps = self.optimizer.optimize(steps)
+        levels = self.scheduler.build_levels(steps)
+        return {
+            "tasks": steps,
+            "levels": levels
+        }

sourcebot/runtime/dag/planner/execution_scheduler.py

@@ -0,0 +1,35 @@
+# sourcebot/planning/execution_scheduler.py
+# DAG → Execution Levels
+
+from typing import List, Dict
+
+
+class ExecutionScheduler:
+
+    def build_levels(self, tasks: List[Dict]) -> List[List[Dict]]:
+        """
+        Convert DAG tasks into execution levels
+        """
+
+        remaining = {t["id"]: set(t.get("depends_on", [])) for t in tasks}
+        task_map = {t["id"]: t for t in tasks}
+
+        levels = []
+
+        while remaining:
+
+            ready = [tid for tid, deps in remaining.items() if not deps]
+
+            if not ready:
+                raise RuntimeError("Cycle detected in DAG")
+
+            level_tasks = [task_map[r] for r in ready]
+            levels.append(level_tasks)
+
+            for r in ready:
+                remaining.pop(r)
+
+            for deps in remaining.values():
+                deps.difference_update(ready)
+
+        return levels

sourcebot/runtime/dag/planner/parallelism_optimizer.py

@@ -0,0 +1,44 @@
+# sourcebot/planning/parallelism_optimizer.py
+
+from typing import Dict, List
+import re
+
+
+class ParallelismOptimizer:
+
+    def __init__(self):
+        pass
+
+    def build_dependencies(self, steps: List[str]) -> Dict[int, List[int]]:
+        """
+        return:
+        step_index -> depends_on
+        """
+        deps = {}
+        for i, step in enumerate(steps):
+            deps[i] = []
+            for j in range(i):
+                if self._has_dependency(steps[j], step):
+                    deps[i].append(j)
+        return deps
+
+    def _has_dependency(self, a: str, b: str) -> bool:
+        keywords = [
+            "after",
+            "based on",
+            "use result",
+            "then",
+            "verify"
+        ]
+        for k in keywords:
+            if k in b.lower():
+                return True
+        return False
+
+    def optimize(self, tasks):
+        # remove redundant dependencies
+        for t in tasks:
+            deps = set(t.get("depends_on", []))
+            # simple dedup
+            t["depends_on"] = list(deps)
+        return tasks

sourcebot/runtime/dag/planner/task_decomposer.py

@@ -0,0 +1,37 @@
+# sourcebot/dag/planner/task_decomposer.py
+
+from typing import List
+import json
+import re
+import logging
+from sourcebot.utils.output import extract_json
+from sourcebot.llm.core.message import Message
+logger = logging.getLogger(__name__)
+
+class TaskDecomposer:
+    
+    def __init__(self, llm, context_builder):
+        self.llm = llm
+        self.context_builder = context_builder
+
+    async def decompose(self, query: str) -> List[str]:
+        if not isinstance(query, str):
+          query = json.dumps(query, ensure_ascii=False, indent=2)
+        skills_summary = self.context_builder.build_skills_summary()
+        rules = self.context_builder.build_rulse()
+        decomposer_prompt = self.context_builder.build_decomposer_prompt()
+        messages = [
+            Message(role = "system", content = decomposer_prompt),
+            Message(role = "user", content = f"""
+USER REQUEST
+
+{query}
+"""),
+        ]
+        
+        result = await self.llm.complete(messages)
+        try:
+            data = extract_json(result.content)
+            return data["tasks"]
+        except Exception as e:
+            logger.error(f"Failed to parse DAG JSON: {e}")

sourcebot/runtime/dag/scheduler/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.runtime.dag.scheduler.dag_scheduler import DAGScheduler
+
+__all__ = ["DAGScheduler"]