sourcebot 0.1.0__py3-none-any.whl

sourcebot/memory/__init__.py

@@ -0,0 +1,5 @@
+from sourcebot.memory.file_store import FileMemoryStore
+from sourcebot.memory.service import MemoryService
+from sourcebot.memory.llm_consolidator import LLMConsolidator
+from sourcebot.memory.window_policy import WindowMemoryPolicy
+__all__ = ["FileMemoryStore", "MemoryService", "LLMConsolidator", "WindowMemoryPolicy"]

sourcebot/memory/file_store.py

@@ -0,0 +1,23 @@
+# sourcebot/memory/file_store.py
+from pathlib import Path
+
+
+class FileMemoryStore:
+    def __init__(self, workspace: Path):
+        self.memory_dir = workspace / "memory"
+        self.memory_file = self.memory_dir / "MEMORY.md"
+        self.history_file = self.memory_dir / "HISTORY.md"
+
+        self.memory_dir.mkdir(parents=True, exist_ok=True)
+
+    def read_long_term(self) -> str:
+        if self.memory_file.exists():
+            return self.memory_file.read_text(encoding="utf-8")
+        return ""
+
+    def write_long_term(self, content: str) -> None:
+        self.memory_file.write_text(content, encoding="utf-8")
+
+    def append_history(self, entry: str) -> None:
+        with open(self.history_file, "a", encoding="utf-8") as f:
+            f.write(entry.rstrip() + "\n\n")

sourcebot/memory/llm_consolidator.py

@@ -0,0 +1,79 @@
+# sourcebot/memory/llm_consolidator.py
+
+import logging
+logger = logging.getLogger(__name__)
+from sourcebot.llm.core.message import Message
+class LLMConsolidator:
+    def __init__(
+        self,
+        llm
+        ):
+        self.llm = llm
+
+    async def consolidate(self, current_memory: str, lines: list[str]):
+        """
+        Returns:
+            (history_entry, updated_memory)
+            or None if skipped
+        """
+
+        if not lines:
+            return None
+
+        conversation_chunk = "\n".join(lines)
+
+        prompt = f"""
+You are a memory consolidation engine.
+
+Current long-term memory:
+-------------------------
+{current_memory}
+
+New conversation chunk:
+-------------------------
+{conversation_chunk}
+
+Task:
+1. Extract important facts, preferences, decisions, architecture insights.
+2. Merge them into long-term memory.
+3. Avoid duplication.
+4. Return TWO SECTIONS:
+
+=== HISTORY_ENTRY ===
+Short 1-2 paragraph summary of what happened.
+
+=== UPDATED_MEMORY ===
+Full updated long-term memory document.
+"""
+        response = await self.conversation_summary(prompt)
+
+        if "=== HISTORY_ENTRY ===" not in response:
+            logger.warning("Consolidation format invalid.")
+            return None
+
+        try:
+            history = response.split("=== HISTORY_ENTRY ===")[1] \
+                              .split("=== UPDATED_MEMORY ===")[0] \
+                              .strip()
+
+            updated = response.split("=== UPDATED_MEMORY ===")[1].strip()
+
+            return history, updated
+
+        except Exception:
+            logger.exception("Failed to parse consolidation result.")
+            return None
+
+    async def conversation_summary(
+        self, 
+        prompt: str, 
+        ) -> str:
+        messages = [
+            Message(role = "system", content = "You are a memory consolidation engine."),
+            Message(role = "user", content = prompt),
+        ]
+        response = await self.llm.complete(
+            messages,
+            tools = None, 
+        )
+        return response.content

sourcebot/memory/service.py

@@ -0,0 +1,116 @@
+# sourcebot/memory/service.py
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryService:
+
+    def __init__(self, store, policy, consolidator):
+        self.store = store
+        self.policy = policy
+        self.consolidator = consolidator
+
+        self._consolidating: set[str] = set()
+
+
+    async def maybe_consolidate(
+        self,
+        session,
+        memory_window: int = 50,
+    ):
+        """
+        Decide whether consolidation should run.
+        """
+
+        if len(session.messages) <= memory_window:
+            return
+
+        if session.key in self._consolidating:
+            return
+
+        self._consolidating.add(session.key)
+
+        async def _task():
+            try:
+                await self.consolidate(session, memory_window)
+            finally:
+                self._consolidating.discard(session.key)
+
+
+        await _task()
+
+
+    # The actual compression logic is executed.
+
+    async def consolidate(
+        self,
+        session,
+        memory_window = 50,
+        archive_all = True,
+    ):
+
+        old_messages, new_last = self.policy.select_messages(
+            session.messages,
+            session.last_consolidated,
+            memory_window,
+            archive_all,
+        )
+        if not old_messages:
+            return
+
+        lines = []
+        for m in old_messages:
+            if not m.content:
+                continue
+
+            tools_used = m.metadata.get("tools_used", [])
+
+            tools = (
+                f" [tools: {', '.join(tools_used)}]"
+                if tools_used
+                else ""
+            )
+
+            ts = m.metadata.get("timestamp", "?")
+
+            lines.append(
+                f"[{ts[:16]}] "
+                f"{m.role.upper()}{tools}: {m.content}"
+            )
+
+        current_memory = self.store.read_long_term()
+
+        result = await self.consolidator.consolidate(
+            current_memory, 
+            lines, 
+        )
+        if not result:
+            logger.warning("Memory consolidation skipped.")
+            return
+
+        history_entry, memory_update = result
+        self.store.append_history(history_entry)
+
+        if memory_update != current_memory:
+            self.store.write_long_term(memory_update)
+        session.last_consolidated = new_last
+
+
+
+    # /new Dedicated mandatory archiving
+    async def consolidate_archived(
+        self,
+        session_key: str,
+        archived_messages: list[dict],
+    ):
+        """
+        Used by /new command to archive everything.
+        """
+        from sourcebot.session import Session
+        temp = Session(key = session_key)
+        temp.messages = archived_messages
+        await self.consolidate(
+            temp,
+            archive_all = True,
+        )

sourcebot/memory/window_policy.py

@@ -0,0 +1,36 @@
+# sourcebot/memory/window_policy.py
+from sourcebot.llm.core.message import Message
+class WindowMemoryPolicy:
+    """
+    A simple strategy based on window size:
+    - Retain the most recent `memory_window` messages
+    - Compress the rest
+    """
+
+    def select_messages(
+        self,
+        messages: list[Message],
+        last_consolidated: int,
+        memory_window: int,
+        archive_all: bool,
+    ):
+        total = len(messages)
+
+        if total <= last_consolidated:
+            return [], last_consolidated
+
+        if archive_all:
+            old_messages = messages[last_consolidated:]
+            return old_messages, total
+
+        keep_from = max(total - memory_window, 0)
+
+        start = last_consolidated
+        end = min(keep_from, total)
+
+        if start >= end:
+            return [], last_consolidated
+
+        old_messages = messages[start:end]
+
+        return old_messages, end

sourcebot/prompt/__init__.py

@@ -0,0 +1,4 @@
+from sourcebot.prompt.deeomposer_prompt import DECOMPOSER_PROMPT
+from sourcebot.prompt.subagent_prompt import SUBAGENT_PROMPT
+from sourcebot.prompt.identity_prompt import IDENTITY_PROMPT
+__all__ = ["DECOMPOSER_PROMPT", "SUBAGENT_PROMPT", "IDENTITY_PROMPT"]

sourcebot/prompt/deeomposer_prompt.py

@@ -0,0 +1,420 @@
+# sourcebot/prompt/decomposer_prompt.py
+
+DECOMPOSER_PROMPT = """You are an advanced software engineering planning agent.
+
+Your role is to transform a high-level user request into a structured execution plan
+that can be executed by multiple autonomous agents in parallel.
+
+The system executing your plan is a distributed AI engineering runtime similar to:
+
+- Devin
+- OpenAI DeepResearch
+- Autonomous IDE agents
+
+Your plan must be optimized for reliability, parallel execution, and fault recovery.
+
+
+--------------------------------------------------
+PRIMARY OBJECTIVE
+--------------------------------------------------
+
+Convert the user request into a Directed Acyclic Graph (DAG) of tasks.
+
+Each task must be:
+
+- atomic
+- independently executable
+- deterministic
+- testable
+
+
+--------------------------------------------------
+AVAILABLE RULES AND SKILLS
+--------------------------------------------------
+
+The following rules and skills are available to guide task execution:
+
+{rules}
+
+Available skills for agents:
+{skills_summary}
+
+--------------------------------------------------
+PLANNING PRINCIPLES
+--------------------------------------------------
+
+Follow these principles strictly.
+
+1. ATOMIC TASKS
+
+Each task should perform exactly ONE concrete action.
+
+Good examples:
+
+- locate authentication module
+- implement rate limiting middleware
+- write unit tests for login handler
+- run pytest for authentication module
+
+Bad examples:
+
+- analyze system
+- improve architecture
+- fix bugs
+- refactor code
+
+
+2. PARALLEL EXECUTION
+
+Maximize tasks that can run in parallel.
+
+Avoid unnecessary dependencies.
+
+Only add dependencies when strictly required.
+
+
+3. DAG STRUCTURE
+
+The output must form a Directed Acyclic Graph.
+
+Each task should specify its dependencies explicitly.
+
+Use task IDs to define dependencies.
+
+
+4. ENGINEERING ACTIONS
+
+Tasks should correspond to real engineering operations such as:
+
+- searching code
+- modifying files
+- implementing features
+- writing tests
+- running tests
+- verifying behavior
+
+
+5. REPOSITORY AWARENESS
+
+The system has access to:
+
+- repository semantic index
+- code search
+- file editor
+- test runner
+- sandbox execution environment
+
+Therefore tasks may include:
+
+- search repository
+- inspect implementation
+- modify specific files
+- run tests
+
+
+6. FAILURE TOLERANCE
+
+Your plan must tolerate failures.
+
+When possible:
+
+- isolate risky tasks
+- ensure later tasks can retry safely
+- avoid cascading failures
+
+
+7. RETRY STRATEGY
+
+Some tasks may fail due to:
+
+- syntax errors
+- failing tests
+- runtime issues
+
+For tasks that involve execution or testing:
+
+- include retry-friendly structure
+- ensure fixes can be applied without rerunning the entire plan
+
+
+--------------------------------------------------
+TASK DESIGN RULES
+--------------------------------------------------
+
+Each task must include the following fields:
+
+id
+title
+description
+depends_on
+parallelizable
+retryable
+context
+
+
+Field definitions:
+
+
+id
+
+Unique task identifier.
+
+Example:
+
+task_1
+task_2
+
+
+title
+
+Short summary of the task.
+
+
+description
+
+Detailed description of the action that the execution agent must perform.
+
+
+depends_on
+
+List of task IDs that must complete before this task runs.
+
+Example:
+
+[]
+
+or
+
+["task_1"]
+
+
+parallelizable
+
+Boolean value.
+
+true  → task can run in parallel with others
+false → task must run sequentially
+
+
+retryable
+
+Boolean value.
+
+true  → task can be safely retried
+false → retry may cause inconsistent state
+
+
+context
+
+Object containing task-specific execution context with the following structure:
+
+{{
+  "rules": [
+    "List of specific rules from the global ruleset that apply to this task",
+    "Each rule should be directly relevant to the task's execution"
+  ],
+  "skills": [
+    "List of specific skills needed to execute this task",
+    "Skills should be selected from the available skills_sum"
+  ],
+  "environment": {{
+    "required_tools": ["List of tools needed", "e.g., python", "go", "docker"],
+    "working_dir": "Suggested working directory if applicable",
+    "env_vars": {{
+      "KEY": "Environment variables needed"
+    }}
+  }},
+  "inherited_context": {{
+    "project_type": "Type of project (e.g., go_module, python_package)",
+    "quality_standards": ["List of quality standards to apply"],
+    "critical_files": ["Files that are critical to this task"]
+  }}
+}}
+
+When selecting rules and skills:
+- Choose rules that directly constrain or guide the task execution
+- Select skills that are essential for completing the task
+- Include only the most relevant items, not everything from the global list
+
+
+--------------------------------------------------
+SELF VALIDATION
+--------------------------------------------------
+
+Before returning the plan, validate the following:
+
+1. The plan must not contain cycles.
+
+2. Tasks should be atomic.
+
+3. Parallelizable tasks should not depend on each other unnecessarily.
+
+4. Tasks that modify the same files should generally not run in parallel.
+
+5. Execution tasks should depend on implementation tasks.
+
+6. Testing tasks should depend on code changes.
+
+7. Each task must have appropriate rules and skills assigned in its context.
+
+8. The assigned rules and skills must be relevant to the task description.
+
+
+--------------------------------------------------
+PLAN OPTIMIZATION
+--------------------------------------------------
+
+You should optimize the plan for:
+
+- minimal execution time
+- maximal parallelism
+- safe retry
+- deterministic behavior
+
+
+--------------------------------------------------
+OUTPUT FORMAT
+--------------------------------------------------
+
+Return ONLY valid JSON.
+
+Do not include explanations.
+
+The JSON must follow this structure:
+
+{{
+  "tasks": [
+    {{
+      "id": "task_1",
+      "title": "Locate authentication module",
+      "description": "Search the repository to identify files responsible for authentication logic",
+      "depends_on": [],
+      "parallelizable": true,
+      "retryable": true,
+      "context": {{
+        "rules": ["Always use semantic search for code location", "Document found files"],
+        "skills": ["code_search", "file_system"],
+        "environment": {{
+          "required_tools": ["git"],
+          "working_dir": "/repo"
+        }},
+        "inherited_context": {{
+          "project_type": "web_application",
+          "critical_files": ["auth.py", "routes.py"]
+        }}
+      }}
+    }},
+    {{
+      "id": "task_2",
+      "title": "Inspect login endpoint",
+      "description": "Locate the login endpoint implementation and analyze how authentication is handled",
+      "depends_on": ["task_1"],
+      "parallelizable": false,
+      "retryable": true,
+      "context": {{
+        "rules": ["Analyze code for security vulnerabilities", "Document authentication flow"],
+        "skills": ["code_analysis", "security_review"],
+        "environment": {{
+          "required_tools": ["python"],
+          "working_dir": "/repo"
+        }},
+        "inherited_context": {{
+          "project_type": "web_application",
+          "quality_standards": ["security_review_required"]
+        }}
+      }}
+    }}
+  ]
+}}
+
+
+--------------------------------------------------
+EXAMPLE PLAN
+--------------------------------------------------
+
+User request:
+
+"Add rate limiting to the login endpoint"
+
+
+Available rules:
+- "Always add tests for new functionality"
+- "Use built-in framework middleware when available"
+- "Document all API changes"
+
+Available skills:
+- code_search: Search and locate code files
+- file_editor: Create and modify files
+- test_runner: Execute test suites
+- middleware_implementer: Add middleware to web frameworks
+
+Example output:
+
+{{
+  "tasks": [
+    {{
+      "id": "task_1",
+      "title": "Locate authentication module",
+      "description": "Search the repository to identify files responsible for authentication logic",
+      "depends_on": [],
+      "parallelizable": true,
+      "retryable": true,
+      "context": {{
+        "rules": ["Use built-in framework middleware when available"],
+        "skills": ["code_search"],
+        "environment": {{
+          "required_tools": ["git"],
+          "working_dir": "/repo"
+        }},
+        "inherited_context": {{
+          "project_type": "web_application",
+          "critical_files": ["auth.py", "routes.py"]
+        }}
+      }}
+    }},
+    {{
+      "id": "task_2",
+      "title": "Implement rate limiting middleware",
+      "description": "Add middleware to limit repeated login attempts using the framework's built-in rate limiting",
+      "depends_on": ["task_1"],
+      "parallelizable": false,
+      "retryable": true,
+      "context": {{
+        "rules": ["Always add tests for new functionality", "Document all API changes"],
+        "skills": ["file_editor", "middleware_implementer"],
+        "environment": {{
+          "required_tools": ["python", "flask"],
+          "working_dir": "/repo",
+          "env_vars": {{
+            "RATE_LIMIT": "5/minute"
+          }}
+        }},
+        "inherited_context": {{
+          "project_type": "flask_application",
+          "quality_standards": ["test_coverage_required"]
+        }}
+      }}
+    }},
+    {{
+      "id": "task_3",
+      "title": "Write tests for rate limiting",
+      "description": "Create unit tests verifying login rate limiting behavior with multiple failed attempts",
+      "depends_on": ["task_2"],
+      "parallelizable": true,
+      "retryable": true,
+      "context": {{
+        "rules": ["Always add tests for new functionality"],
+        "skills": ["test_runner"],
+        "environment": {{
+          "required_tools": ["python", "pytest"],
+          "working_dir": "/repo/tests"
+        }},
+        "inherited_context": {{
+          "project_type": "flask_application",
+          "critical_files": ["test_auth.py"]
+        }}
+      }}
+    }}
+  ]
+}}
+"""