repopilot-agent 0.1.0__py3-none-any.whl

repopilot/__init__.py

@@ -0,0 +1,3 @@
+"""RepoPilot — Local-first code agent."""
+from __future__ import annotations
+__version__ = "0.1.0"

repopilot/__main__.py

@@ -0,0 +1,3 @@
+"""Allow running RepoPilot with: python -m repopilot"""
+from repopilot.cli import app
+app()

repopilot/agent/compact.py

@@ -0,0 +1,192 @@
+"""Three-level context compaction for long agent sessions.
+
+Levels:
+- tool_compact: Rule-based truncation of tool outputs (no LLM call)
+- micro_compact: Use fast LLM to summarize oldest 3-5 steps into 1-2 sentences
+- auto_compact: Use fast LLM to summarize everything except recent K steps into
+  a structured summary (completed actions / key findings / file locations / unresolved issues)
+
+Token counting uses the approximation len(text) // 4 (works for mixed Chinese/English/code).
+When real token counts are available from LLM usage responses, call update_actual_usage()
+to calibrate.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional, Protocol, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+CHARS_PER_TOKEN = 4
+
+
+def estimate_tokens(text: str) -> int:
+    """Rough token estimate: ~4 chars per token for code/English/mixed."""
+    if not text:
+        return 0
+    return max(1, len(text) // CHARS_PER_TOKEN)
+
+
+def tool_compact(text: str, max_chars: int = 12000, max_lines: int = 200) -> str:
+    """Rule-based truncation for tool output. No LLM call.
+
+    - If output fits, return as-is.
+    - Otherwise keep head + tail with a truncation notice in between.
+    - Always cap total lines to max_lines.
+    """
+    if not text:
+        return ""
+    if len(text) <= max_chars and text.count("\n") <= max_lines:
+        return text
+
+    lines = text.split("\n")
+    if len(lines) > max_lines:
+        head = lines[: max_lines // 2]
+        tail = lines[-max_lines // 4 :]
+        omitted_lines = len(lines) - len(head) - len(tail)
+        text = "\n".join(head) + f"\n\n... ({omitted_lines} lines omitted due to output limit) ...\n\n" + "\n".join(tail)
+
+    if len(text) > max_chars:
+        head_chars = max_chars * 2 // 3
+        tail_chars = max_chars // 6
+        omitted = len(text) - head_chars - tail_chars
+        text = text[:head_chars] + f"\n\n... ({omitted} chars omitted) ...\n\n" + text[-tail_chars:]
+
+    return text
+
+
+@dataclass
+class CompactResult:
+    """Result of a compaction operation."""
+    summary: str
+    steps_compacted: int
+    tokens_saved: int
+
+
+class LLMProtocol(Protocol):
+    """Protocol for LLM service (avoids circular import)."""
+    def chat_fast(self, messages: list[dict], **kwargs) -> str: ...
+
+
+MICRO_COMPACT_PROMPT = """\
+You are summarizing an old segment of a coding agent's conversation history.
+Below are {n_steps} steps (user messages, assistant responses, and tool results).
+Summarize them in 1-2 concise sentences, preserving:
+- What was attempted
+- Key outcomes or errors
+- Any file paths or symbols that matter
+
+Keep the summary under 80 words. Do NOT add speculation. Output only the summary.
+
+Steps to summarize:
+{steps_text}
+"""
+
+AUTO_COMPACT_PROMPT = """\
+You are compressing a long coding agent conversation to fit within the context window.
+Below is the conversation history (excluding the most recent {keep_recent} steps which are kept verbatim).
+Produce a structured summary with exactly these sections:
+
+## Completed Actions
+- List concrete actions taken (files read/written/edited, commands run, tests executed)
+
+## Key Findings
+- Important discoveries: bugs found, code patterns identified, test failures observed
+
+## File Locations
+- Files and line numbers that were relevant (e.g., src/main.py:42)
+
+## Unresolved
+- Issues not yet addressed, errors still failing, next steps needed
+
+Keep each bullet point under 20 words. Be specific (use actual filenames/symbols from the text).
+Do NOT include information not present in the conversation. Total summary should be under 400 words.
+
+Conversation to summarize:
+{steps_text}
+"""
+
+
+def _format_steps_for_summary(steps: list[dict]) -> str:
+    """Format a list of step dicts into text for LLM summarization."""
+    parts = []
+    for i, step in enumerate(steps, 1):
+        role = step.get("role", step.get("type", "unknown"))
+        content = step.get("content", step.get("text", ""))
+        if isinstance(content, list):
+            content_parts = []
+            for c in content:
+                if isinstance(c, dict):
+                    content_parts.append(c.get("text", c.get("content", str(c))))
+                else:
+                    content_parts.append(str(c))
+            content = "\n".join(content_parts)
+        parts.append(f"[{i}] {role}: {content}")
+    return "\n\n".join(parts)
+
+
+def micro_compact(steps: list[dict], llm: Any) -> CompactResult:
+    """Use fast LLM to summarize the oldest 3-5 steps into 1-2 sentences.
+
+    `steps` is a list of message dicts (role/content pairs).
+    `llm` must have a `chat_fast(messages) -> str` method.
+    """
+    if not steps:
+        return CompactResult(summary="", steps_compacted=0, tokens_saved=0)
+
+    steps_text = _format_steps_for_summary(steps)
+    original_tokens = estimate_tokens(steps_text)
+
+    prompt = MICRO_COMPACT_PROMPT.format(n_steps=len(steps), steps_text=steps_text)
+    try:
+        from repopilot.llm.service import Tier
+        resp = llm.chat([
+            {"role": "system", "content": "You are a concise summarizer."},
+            {"role": "user", "content": prompt},
+        ], tier=Tier.FAST)
+        summary = resp.content
+    except Exception:
+        summary = f"[{len(steps)} earlier steps summarized but LLM unavailable]"
+
+    summary_tokens = estimate_tokens(summary)
+    return CompactResult(
+        summary=summary.strip(),
+        steps_compacted=len(steps),
+        tokens_saved=max(0, original_tokens - summary_tokens),
+    )
+
+
+def auto_compact(steps: list[dict], llm: Any, keep_recent: int = 10) -> CompactResult:
+    """Use fast LLM to produce a structured summary of older steps.
+
+    Steps[-keep_recent:] are NOT included (caller keeps those verbatim).
+    Everything in steps[:-keep_recent] is summarized.
+    """
+    if not steps:
+        return CompactResult(summary="", steps_compacted=0, tokens_saved=0)
+
+    to_compact = steps[:-keep_recent] if len(steps) > keep_recent else steps
+    if not to_compact:
+        return CompactResult(summary="", steps_compacted=0, tokens_saved=0)
+
+    steps_text = _format_steps_for_summary(to_compact)
+    original_tokens = estimate_tokens(steps_text)
+
+    prompt = AUTO_COMPACT_PROMPT.format(keep_recent=keep_recent, steps_text=steps_text)
+    try:
+        from repopilot.llm.service import Tier
+        resp = llm.chat([
+            {"role": "system", "content": "You are a precise engineering summarizer."},
+            {"role": "user", "content": prompt},
+        ], tier=Tier.FAST)
+        summary = resp.content
+    except Exception:
+        summary = f"## Summary\n[{len(to_compact)} earlier steps - LLM unavailable for detailed summary]"
+
+    summary_tokens = estimate_tokens(summary)
+    return CompactResult(
+        summary=summary.strip(),
+        steps_compacted=len(to_compact),
+        tokens_saved=max(0, original_tokens - summary_tokens),
+    )

repopilot/agent/context.py

@@ -0,0 +1,236 @@
+"""Context Manager: builds LLM message arrays with layered context and automatic compaction.
+
+Message assembly order (top to bottom = first to last in messages array):
+  1. System prompt (L0): fixed instructions ~800 tokens
+  2. Project context (L0.5): REPOPILOT.md content (if exists), repo map, memory, injected skills
+  3. Plan segment: current plan from planner
+  4. Compacted summary (L2): result of micro/auto compact (when triggered)
+  5. Recent steps (L1): verbatim recent messages, fit within remaining budget
+  6. Pending tool result: last tool output (already tool-compacted)
+
+Token budget:
+  - system + project context ~5000 tokens
+  - plan + summary ~1000-2000 tokens
+  - recent steps fill the remainder up to budget_tokens
+  - tool-compact always applied to tool outputs before storing
+
+When token_usage_ratio() exceeds thresholds:
+  - 0.75+: trigger micro_compact (summarize oldest 3-5 steps)
+  - 0.90+: trigger auto_compact (summarize all but last K steps)
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from repopilot.agent.compact import (
+    estimate_tokens,
+    tool_compact,
+    micro_compact,
+    auto_compact,
+    CompactResult,
+)
+
+# Default allocation (tokens)
+SYSTEM_RESERVE = 1000
+PROJECT_RESERVE = 5000
+PLAN_RESERVE = 1000
+SUMMARY_RESERVE = 2000
+RECENT_STEPS_KEEP = 10
+MICRO_COMPACT_THRESHOLD = 0.75
+AUTO_COMPACT_THRESHOLD = 0.90
+TOOL_OUTPUT_MAX_CHARS = 12000
+TOOL_OUTPUT_MAX_LINES = 200
+
+
+@dataclass
+class Step:
+    """A single conversation turn or tool interaction."""
+    role: str  # "user" | "assistant" | "tool" | "plan" | "observation"
+    content: str
+    tool_calls: Optional[list[dict]] = None
+    tool_call_id: Optional[str] = None
+    step_type: str = "message"  # "message" | "tool_result" | "plan" | "observation"
+    tokens: int = 0
+
+    def __post_init__(self):
+        if self.tokens == 0:
+            self.tokens = estimate_tokens(self.content) + (
+                30 * (len(self.tool_calls) if self.tool_calls else 0)
+            )
+
+    def to_message(self) -> dict:
+        """Convert to OpenAI-style message dict."""
+        msg: dict[str, Any] = {"role": self.role, "content": self.content}
+        if self.tool_calls:
+            msg["tool_calls"] = self.tool_calls
+        if self.tool_call_id:
+            msg["tool_call_id"] = self.tool_call_id
+        return msg
+
+
+@dataclass
+class ContextManager:
+    """Manages conversation context with layered assembly and automatic compaction."""
+
+    budget_tokens: int = 120000
+    system_prompt: str = ""
+    repo_map_str: str = ""
+    memory_str: str = ""
+    injected_skills: str = ""
+    plan: str = ""
+    summary: str = ""
+    steps: list[Step] = field(default_factory=list)
+    pending_tool_result: Optional[Step] = None
+    _actual_usage_calibration: float = 1.0
+
+    def set_plan(self, plan: str) -> None:
+        self.plan = plan
+
+    def add_observation(self, text: str) -> None:
+        self.steps.append(Step(role="system", content=text, step_type="observation"))
+
+    def add_assistant(self, text: str, tool_calls: Optional[list[dict]] = None) -> None:
+        content = text or ""
+        self.steps.append(Step(role="assistant", content=content, tool_calls=tool_calls))
+
+    def add_user(self, text: str) -> None:
+        self.steps.append(Step(role="user", content=text))
+
+    def add_tool_result(self, tool_call_id: str, content: str, is_error: bool = False) -> None:
+        compacted = tool_compact(content, TOOL_OUTPUT_MAX_CHARS, TOOL_OUTPUT_MAX_LINES)
+        prefix = "Error: " if is_error else ""
+        self.steps.append(Step(
+            role="tool",
+            content=prefix + compacted,
+            tool_call_id=tool_call_id,
+            step_type="tool_result",
+        ))
+
+    def inject_skill_prompt(self, text: str) -> None:
+        if text and text not in self.injected_skills:
+            self.injected_skills += ("\n" + text if self.injected_skills else text)
+
+    def recent_steps(self, n: int = 20) -> list[dict]:
+        return [s.to_message() for s in self.steps[-n:]]
+
+    def token_usage_ratio(self) -> float:
+        used = self._current_total_tokens()
+        return used / self.budget_tokens if self.budget_tokens > 0 else 1.0
+
+    def _system_tokens(self) -> int:
+        return estimate_tokens(self.system_prompt) + 200  # small overhead for message structure
+
+    def _project_tokens(self) -> int:
+        parts = [self.repo_map_str, self.memory_str, self.injected_skills]
+        return sum(estimate_tokens(p) for p in parts)
+
+    def _plan_tokens(self) -> int:
+        return estimate_tokens(self.plan) if self.plan else 0
+
+    def _summary_tokens(self) -> int:
+        return estimate_tokens(self.summary) if self.summary else 0
+
+    def _current_total_tokens(self) -> int:
+        steps_tokens = sum(s.tokens for s in self.steps)
+        return (self._system_tokens() + self._project_tokens() +
+                self._plan_tokens() + self._summary_tokens() + steps_tokens)
+
+    def build_messages(self, task: Optional[str] = None) -> list[dict]:
+        """Assemble the full message array for the LLM.
+
+        Order: system → project context → plan → summary → recent steps → pending tool → (optional task).
+        """
+        messages: list[dict] = []
+
+        # L0: system prompt
+        system_parts = []
+        if self.system_prompt:
+            system_parts.append(self.system_prompt)
+        messages.append({"role": "system", "content": "\n\n".join(system_parts) if system_parts else "You are a helpful coding assistant."})
+
+        # L0.5: project context
+        project_parts = []
+        if self.repo_map_str:
+            project_parts.append(f"## Repository Structure\n{self.repo_map_str}")
+        if self.memory_str:
+            project_parts.append(f"## Memory / Notes\n{self.memory_str}")
+        if self.injected_skills:
+            project_parts.append(f"## Available Skills\n{self.injected_skills}")
+        if project_parts:
+            messages.append({"role": "system", "content": "\n\n".join(project_parts)})
+
+        # Plan
+        if self.plan:
+            messages.append({"role": "system", "content": f"## Current Plan\n{self.plan}"})
+
+        # L2: compacted summary
+        if self.summary:
+            messages.append({"role": "system", "content": f"## Earlier Work Summary\n{self.summary}"})
+
+        # L1: recent steps (all steps fit within budget; compaction handles trimming)
+        remaining_budget = self.budget_tokens - (
+            self._system_tokens() + self._project_tokens() +
+            self._plan_tokens() + self._summary_tokens()
+        )
+        steps_to_include = self._select_steps_for_budget(remaining_budget)
+        for step in steps_to_include:
+            messages.append(step.to_message())
+
+        # Pending tool result
+        if self.pending_tool_result:
+            messages.append(self.pending_tool_result.to_message())
+
+        # Task as final user message
+        if task:
+            messages.append({"role": "user", "content": task})
+
+        return messages
+
+    def _select_steps_for_budget(self, budget: int) -> list[Step]:
+        """Select steps to include, preferring the most recent ones."""
+        if budget <= 0:
+            budget = 4000
+        included: list[Step] = []
+        used = 0
+        for step in reversed(self.steps):
+            if used + step.tokens > budget and included:
+                break
+            included.insert(0, step)
+            used += step.tokens
+        return included
+
+    def needs_compaction(self) -> Optional[str]:
+        """Return 'micro', 'auto', or None based on current token ratio."""
+        ratio = self.token_usage_ratio()
+        if ratio >= AUTO_COMPACT_THRESHOLD:
+            return "auto"
+        if ratio >= MICRO_COMPACT_THRESHOLD:
+            return "micro"
+        return None
+
+    def compact(self, level: str, llm: Any) -> CompactResult:
+        """Trigger a compaction at the given level ('micro' or 'auto')."""
+        if level == "micro":
+            to_compact = self.steps[:5] if len(self.steps) > RECENT_STEPS_KEEP else self.steps[:3]
+            result = micro_compact([s.to_message() for s in to_compact], llm)
+            if result.summary:
+                self.summary = (self.summary + "\n\n" if self.summary else "") + result.summary
+                self.steps = self.steps[len(to_compact):]
+            return result
+        elif level == "auto":
+            keep_recent = RECENT_STEPS_KEEP
+            steps_as_msgs = [s.to_message() for s in self.steps]
+            result = auto_compact(steps_as_msgs, llm, keep_recent=keep_recent)
+            if result.summary:
+                self.summary = result.summary
+                self.steps = self.steps[-keep_recent:] if len(self.steps) > keep_recent else self.steps
+            return result
+        else:
+            return CompactResult(summary="", steps_compacted=0, tokens_saved=0)
+
+    def update_actual_usage(self, prompt_tokens: int) -> None:
+        """Calibrate token estimates with real usage data from API response."""
+        estimated = self._current_total_tokens()
+        if estimated > 0:
+            self._actual_usage_calibration = prompt_tokens / estimated

repopilot/agent/cost.py

@@ -0,0 +1,119 @@
+"""Cost tracker — accumulates token usage and estimated cost across an agent session."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+# Fallback per-token prices (USD per 1M tokens) when litellm.model_cost is not available.
+# These are approximate list prices as of 2025 for common models.
+_FALLBACK_PRICES = {
+    # Volcengine ARK / Doubao
+    "doubao-seed-evolving":        {"input": 0.30, "output": 0.60},
+    "doubao-seed-2-1-turbo-260628": {"input": 0.15, "output": 0.30},
+    "doubao-seed-2-1-pro-260628":  {"input": 0.50, "output": 2.00},
+    "doubao-seed-1-6-flash-250828": {"input": 0.03, "output": 0.06},
+    "doubao-seed-2-0-code-preview-260215": {"input": 0.20, "output": 0.60},
+    "doubao-seed-2-0-mini-260428": {"input": 0.05, "output": 0.10},
+    # Zhipu
+    "glm-4-7-251222":              {"input": 0.50, "output": 1.50},
+    "glm-5-2-260617":              {"input": 0.60, "output": 2.00},
+    # DeepSeek
+    "deepseek-v3-2-251201":        {"input": 0.14, "output": 0.28},
+}
+
+
+def _lookup_price(model: str) -> tuple[float, float]:
+    """Return (input_price_per_1M, output_price_per_1M) for model, in USD.
+
+    Tries litellm.model_cost first; falls back to _FALLBACK_PRICES by
+    stripping provider prefix.  Returns (0, 0) if unknown.
+    """
+    try:
+        import litellm
+        info = litellm.model_cost.get(model) or litellm.model_cost.get(model.split("/")[-1])
+        if info:
+            return (
+                float(info.get("input_cost_per_token", 0)) * 1_000_000,
+                float(info.get("output_cost_per_token", 0)) * 1_000_000,
+            )
+    except Exception:
+        pass
+    # Strip provider prefix ("openai/doubao-..." -> "doubao-...")
+    short = model.split("/")[-1]
+    if short in _FALLBACK_PRICES:
+        p = _FALLBACK_PRICES[short]
+        return p["input"], p["output"]
+    return 0.0, 0.0
+
+
+@dataclass
+class CostTracker:
+    """Accumulates token usage, cost estimates, and tool timing for one session."""
+
+    total_prompt_tokens: int = 0
+    total_completion_tokens: int = 0
+    total_cost_usd: float = 0.0
+    tool_calls: int = 0
+    tool_duration_ms: int = 0
+    llm_calls: int = 0
+    _per_model: dict[str, dict] = field(default_factory=dict, repr=False)
+
+    def on_llm_call(self, usage: dict, model: str) -> None:
+        """Record token usage from one LLM response."""
+        prompt_tok = int(usage.get("prompt_tokens", 0) or 0)
+        completion_tok = int(usage.get("completion_tokens", 0) or 0)
+        self.total_prompt_tokens += prompt_tok
+        self.total_completion_tokens += completion_tok
+        self.llm_calls += 1
+
+        in_price, out_price = _lookup_price(model)
+        call_cost = (prompt_tok / 1_000_000 * in_price +
+                     completion_tok / 1_000_000 * out_price)
+        self.total_cost_usd += call_cost
+
+        # Per-model breakdown
+        if model not in self._per_model:
+            self._per_model[model] = {"prompt": 0, "completion": 0, "cost": 0.0, "calls": 0}
+        self._per_model[model]["prompt"] += prompt_tok
+        self._per_model[model]["completion"] += completion_tok
+        self._per_model[model]["cost"] += call_cost
+        self._per_model[model]["calls"] += 1
+
+    def on_tool_call(self, tool_name: str, duration_ms: int) -> None:
+        """Record a tool execution."""
+        self.tool_calls += 1
+        self.tool_duration_ms += max(0, duration_ms)
+
+    def summary(self) -> dict:
+        """Return a summary dict suitable for display / logging."""
+        return {
+            "llm_calls": self.llm_calls,
+            "total_tokens": self.total_prompt_tokens + self.total_completion_tokens,
+            "prompt_tokens": self.total_prompt_tokens,
+            "completion_tokens": self.total_completion_tokens,
+            "estimated_cost_usd": round(self.total_cost_usd, 6),
+            "tool_calls": self.tool_calls,
+            "tool_duration_s": round(self.tool_duration_ms / 1000, 2),
+            "per_model": self._per_model,
+        }
+
+    def reset(self) -> None:
+        """Reset all counters to zero."""
+        self.total_prompt_tokens = 0
+        self.total_completion_tokens = 0
+        self.total_cost_usd = 0.0
+        self.tool_calls = 0
+        self.tool_duration_ms = 0
+        self.llm_calls = 0
+        self._per_model.clear()
+
+    def format_summary(self) -> str:
+        """Human-readable one-line summary."""
+        s = self.summary()
+        cost_str = f"${s['estimated_cost_usd']:.4f}" if s["estimated_cost_usd"] > 0 else "(price data unavailable)"
+        return (
+            f"LLM calls: {s['llm_calls']}  "
+            f"Tokens: {s['prompt_tokens']}in + {s['completion_tokens']}out  "
+            f"Cost: {cost_str}  "
+            f"Tools: {s['tool_calls']} calls ({s['tool_duration_s']}s)"
+        )