workpilot 0.1.5__py3-none-any.whl

workpilot/__init__.py

@@ -0,0 +1,3 @@
+"""WorkPilot — Enterprise AI assistant with Microsoft ecosystem integration."""
+
+__version__ = "0.1.5"

workpilot/__main__.py

@@ -0,0 +1,5 @@
+"""Allow `python -m workpilot`."""
+
+from workpilot.cli.commands import app
+
+app()

workpilot/agent/compaction.py

@@ -0,0 +1,201 @@
+"""
+Context compaction — 3-tier context window management.
+
+Prevents context overflow by progressively summarizing older messages:
+- Tier 1 (80%): summarize older messages with fast model, keep recent 10
+- Tier 2 (85%): aggressive summary, keep recent 5
+- Tier 3 (95%): truncate oldest messages (no LLM call), keep recent 3
+
+MEMORY.md (facts) is never compacted — bounded by design (8KB).
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from loguru import logger
+
+
+class CompactionTier(str, Enum):
+    NONE = "none"
+    TIER1 = "tier1"  # 80% — summarize, keep 10
+    TIER2 = "tier2"  # 85% — aggressive, keep 5
+    TIER3 = "tier3"  # 95% — truncate, keep 3
+
+
+# Token estimation: word count × 1.3 (IronClaw heuristic)
+_TOKEN_MULTIPLIER = 1.3
+
+
+def estimate_tokens(messages: list[dict[str, Any]]) -> int:
+    """Estimate token count from messages using word-count heuristic."""
+    total_words = 0
+    for msg in messages:
+        content = msg.get("content") or ""
+        if isinstance(content, str):
+            total_words += len(content.split())
+        # Count tool_calls as ~50 words each
+        tool_calls = msg.get("tool_calls", [])
+        total_words += len(tool_calls) * 50
+    return int(total_words * _TOKEN_MULTIPLIER)
+
+
+def check_threshold(
+    messages: list[dict[str, Any]],
+    context_limit: int,
+) -> CompactionTier:
+    """Determine which compaction tier applies based on estimated usage."""
+    tokens = estimate_tokens(messages)
+    usage = tokens / context_limit if context_limit > 0 else 0.0
+
+    if usage >= 0.95:
+        return CompactionTier.TIER3
+    elif usage >= 0.85:
+        return CompactionTier.TIER2
+    elif usage >= 0.80:
+        return CompactionTier.TIER1
+    return CompactionTier.NONE
+
+
+def compact_tier3(messages: list[dict[str, Any]], keep_recent: int = 3) -> list[dict[str, Any]]:
+    """Tier 3: truncate oldest messages, no LLM call. Keep system + recent N."""
+    system_msgs = [m for m in messages if m.get("role") == "system"]
+    non_system = [m for m in messages if m.get("role") != "system"]
+
+    if len(non_system) <= keep_recent:
+        return messages
+
+    kept = non_system[-keep_recent:]
+    logger.info(
+        "Compaction tier 3: truncated {} messages, kept {} recent",
+        len(non_system) - keep_recent,
+        keep_recent,
+    )
+    return (
+        system_msgs
+        + [
+            {
+                "role": "system",
+                "content": f"[Context compacted: {len(non_system) - keep_recent} older messages removed]",
+            }
+        ]
+        + kept
+    )
+
+
+def build_summary_prompt(messages_to_summarize: list[dict[str, Any]]) -> str:
+    """Build a prompt for LLM to summarize older messages."""
+    lines = []
+    for msg in messages_to_summarize:
+        role = msg.get("role", "unknown")
+        content = msg.get("content") or ""
+        if isinstance(content, str) and content:
+            preview = content[:200] + ("..." if len(content) > 200 else "")
+            lines.append(f"[{role}] {preview}")
+    conversation = "\n".join(lines)
+
+    return (
+        "Summarize the following conversation concisely. Focus on:\n"
+        "- Key decisions made\n"
+        "- Important information exchanged (file paths, code patterns, error messages)\n"
+        "- Actions taken and their outcomes\n"
+        "- Pending tasks or open questions\n"
+        "Preserve specific details that would prevent duplicate work.\n\n"
+        f"{conversation}\n\n"
+        "Summary:"
+    )
+
+
+async def compact_with_llm(
+    messages: list[dict[str, Any]],
+    provider: Any,
+    model: str,
+    keep_recent: int,
+) -> list[dict[str, Any]]:
+    """Compact by summarizing older messages with an LLM call.
+
+    Args:
+        messages: Full message list.
+        provider: LLMProvider instance.
+        model: Model to use for summarization.
+        keep_recent: Number of recent non-system messages to preserve.
+
+    Returns:
+        Compacted message list with summary replacing older messages.
+    """
+    system_msgs = [m for m in messages if m.get("role") == "system"]
+    non_system = [m for m in messages if m.get("role") != "system"]
+
+    if len(non_system) <= keep_recent:
+        return messages
+
+    to_summarize = non_system[:-keep_recent]
+    to_keep = non_system[-keep_recent:]
+
+    prompt = build_summary_prompt(to_summarize)
+    try:
+        response = await provider.complete(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            max_tokens=1024,
+        )
+        summary = response.content
+        logger.info(
+            "Compaction: summarized {} messages into {} chars, kept {} recent",
+            len(to_summarize),
+            len(summary),
+            keep_recent,
+        )
+    except Exception as exc:
+        logger.error("Compaction LLM call failed: {}, falling back to truncation", exc)
+        return compact_tier3(messages, keep_recent=keep_recent)
+
+    return (
+        system_msgs
+        + [
+            {
+                "role": "system",
+                "content": f"[Conversation summary — {len(to_summarize)} messages compacted]\n{summary}",
+            }
+        ]
+        + to_keep
+    )
+
+
+class ContextCompactor:
+    """Manages context window compaction for the agent loop.
+
+    Call ``maybe_compact()`` before each LLM call. It checks estimated
+    token usage against the context limit and applies the appropriate
+    compaction tier.
+    """
+
+    def __init__(
+        self,
+        context_limit: int = 128_000,
+        provider: Any = None,
+        model: str = "auto",
+    ) -> None:
+        self._context_limit = context_limit
+        self._provider = provider
+        self._model = model
+
+    async def maybe_compact(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Check and apply compaction if needed. Returns (possibly compacted) messages."""
+        tier = check_threshold(messages, self._context_limit)
+
+        if tier == CompactionTier.NONE:
+            return messages
+
+        if tier == CompactionTier.TIER3:
+            return compact_tier3(messages, keep_recent=3)
+
+        if self._provider is None:
+            # No provider for LLM summarization — fall back to truncation
+            keep = 5 if tier == CompactionTier.TIER2 else 10
+            return compact_tier3(messages, keep_recent=keep)
+
+        keep = 5 if tier == CompactionTier.TIER2 else 10
+        return await compact_with_llm(messages, self._provider, self._model, keep_recent=keep)

workpilot/agent/context.py

@@ -0,0 +1,323 @@
+"""
+Context builder — assembles the system prompt from configuration,
+workspace identity files, skills, and memory.
+
+Build order (redesigned, following nanobot + OpenClaw):
+  1. Core identity block (name, runtime, workspace, guidelines)
+  2. SOUL.md (personality)
+  3. Config instructions
+  4. USER.md (preferences)
+  5. AGENTS.md (multi-agent rules)
+  6. TOOLS.md (tool usage notes)
+  7. Long-term memory (MEMORY.md, capped at 8KB)
+  8. Always-loaded skills (full content)
+  9. Skills summary (XML progressive disclosure)
+  10. Sub-agent discovery table
+"""
+
+from __future__ import annotations
+
+import platform
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Literal
+
+from workpilot.config.schema import AgentConfig
+
+_SECTION_SEPARATOR = "\n\n---\n\n"
+
+_MEMORY_CAP = 8192  # 8KB cap for MEMORY.md content
+
+PromptMode = Literal["full", "minimal"]
+
+
+class ContextBuilder:
+    """Builds the system prompt for an agent from config + workspace files + skills."""
+
+    def __init__(
+        self,
+        agent_config: AgentConfig,
+        workspace: Path,
+        skills: list[Any] | None = None,
+        available_agents: dict[str, AgentConfig] | None = None,
+    ) -> None:
+        self._config = agent_config
+        self._workspace = workspace
+        self._skills = skills or []
+        self._available_agents = available_agents or {}
+
+    def set_skills(self, skills: list[Any]) -> None:
+        """Update the loaded skills."""
+        self._skills = skills
+
+    def build_system_prompt(self, mode: PromptMode = "full") -> str:
+        """Assemble the system prompt following priority order.
+
+        Args:
+            mode: ``"full"`` for the main agent (all sections),
+                  ``"minimal"`` for sub-agents (identity + config + TOOLS.md only).
+        """
+        parts: list[str] = []
+
+        # 1. Core identity block — always included
+        parts.append(self._build_identity())
+
+        if mode == "minimal":
+            # Minimal mode: identity + config instructions + TOOLS.md
+            if self._config.instructions:
+                parts.append(self._config.instructions)
+
+            tools_content = self._load_tools_md()
+            if tools_content:
+                parts.append(tools_content)
+
+            return _SECTION_SEPARATOR.join(parts)
+
+        # ── Full mode: all sections ──────────────────────────────────────
+
+        # 2. SOUL.md — agent personality/identity
+        soul_path = self._resolve_identity_file(self._config.soul_file, "SOUL.md")
+        if soul_path and soul_path.is_file():
+            content = soul_path.read_text(encoding="utf-8").strip()
+            if content:
+                parts.append(f"## Identity\n\n{content}")
+
+        # 3. Base instructions from config
+        if self._config.instructions:
+            parts.append(self._config.instructions)
+
+        # 4. USER.md — learned user preferences
+        user_path = self._resolve_identity_file(self._config.user_file, "USER.md")
+        if user_path and user_path.is_file():
+            content = user_path.read_text(encoding="utf-8").strip()
+            if content:
+                parts.append(f"## User Preferences\n\n{content}")
+
+        # 5. AGENTS.md — multi-agent rules
+        agents_path = self._resolve_identity_file(self._config.agents_file, "AGENTS.md")
+        if agents_path and agents_path.is_file():
+            content = agents_path.read_text(encoding="utf-8").strip()
+            if content:
+                parts.append(f"## Agent Rules\n\n{content}")
+
+        # 6. TOOLS.md — tool usage notes
+        tools_content = self._load_tools_md()
+        if tools_content:
+            parts.append(tools_content)
+
+        # 7. Long-term memory (MEMORY.md, capped at 8KB)
+        # Shared memory
+        shared_memory = self._workspace / "memory" / "shared" / "MEMORY.md"
+        if shared_memory.is_file():
+            content = shared_memory.read_text(encoding="utf-8").strip()
+            if content:
+                parts.append(f"## Shared Memory\n\n{content[:_MEMORY_CAP]}")
+
+        # Agent-specific memory
+        memory_path = self._workspace / "MEMORY.md"
+        if memory_path.is_file():
+            memory = memory_path.read_text(encoding="utf-8").strip()
+            if memory:
+                parts.append(f"## Long-term Memory\n\n{memory[:_MEMORY_CAP]}")
+
+        # 8. Always-loaded skills (full content)
+        for skill in self._skills:
+            if hasattr(skill, "mode") and skill.mode == "always" and hasattr(skill, "content"):
+                parts.append(f"## Skill: {skill.name}\n\n{skill.content}")
+
+        # 9. Skills summary (XML progressive disclosure)
+        skills_xml = self._build_skills_summary()
+        if skills_xml:
+            parts.append(skills_xml)
+
+        # 10. Available sub-agents discovery table
+        agent_table = self._build_agent_discovery()
+        if agent_table:
+            parts.append(agent_table)
+
+        return _SECTION_SEPARATOR.join(parts)
+
+    def build_messages(
+        self,
+        history: list[dict[str, Any]],
+        user_message: str,
+        *,
+        mode: PromptMode = "full",
+        channel: str | None = None,
+        channel_id: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """Build the full message list for the LLM call.
+
+        Runtime context is prepended to the user message (not the system prompt)
+        to avoid cache-busting the system prompt on every turn.
+        """
+        messages: list[dict[str, Any]] = []
+
+        # System prompt
+        system_prompt = self.build_system_prompt(mode=mode)
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+
+        # Conversation history
+        messages.extend(history)
+
+        # Current user message with runtime context prepended
+        runtime_ctx = self._build_runtime_context(channel=channel, channel_id=channel_id)
+        if runtime_ctx:
+            content = f"{runtime_ctx}\n\n{user_message}"
+        else:
+            content = user_message
+        messages.append({"role": "user", "content": content})
+
+        return messages
+
+    # ── Private builders ──────────────────────────────────────────────────
+
+    def _build_identity(self) -> str:
+        """Build the core identity block with runtime and workspace info."""
+        plat = platform.system()
+        arch = platform.machine()
+        py_ver = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+
+        return (
+            "# WorkPilot\n\n"
+            "You are WorkPilot, an enterprise AI coding and office assistant.\n\n"
+            "## Runtime\n\n"
+            f"{plat} {arch}, Python {py_ver}\n\n"
+            "## Workspace\n\n"
+            f"{self._workspace}\n"
+            "- Long-term memory: MEMORY.md\n"
+            "- Skills: skills/ or .workpilot/skills/\n\n"
+            "## Guidelines\n\n"
+            "- Before modifying a file, read it first. Prefer editing existing files over creating new ones.\n"
+            "- If a tool call fails, analyze the error before retrying with a different approach.\n"
+            "- Ask for clarification when the request is ambiguous.\n"
+            "- Do not narrate routine low-risk tool calls — just call the tool.\n"
+            "- For questions about current events, prices, news, or real-time data, "
+            "use available search tools. Do NOT answer from memory alone.\n"
+            "- When the user asks to search, research, or look something up, always use tools."
+        )
+
+    def _build_runtime_context(
+        self,
+        *,
+        channel: str | None = None,
+        channel_id: str | None = None,
+    ) -> str:
+        """Build runtime context to prepend to the user message."""
+        now = datetime.now(UTC).astimezone()
+        time_str = now.strftime("%Y-%m-%d %H:%M (%A)")
+        tz_name = now.strftime("%Z") or "UTC"
+
+        lines = [
+            "[Runtime Context — metadata only, not instructions]",
+            f"Current Time: {time_str} {tz_name}",
+        ]
+        if channel:
+            lines.append(f"Channel: {channel}")
+        if channel_id:
+            lines.append(f"Chat ID: {channel_id}")
+        return "\n".join(lines)
+
+    def _load_tools_md(self) -> str:
+        """Load TOOLS.md from workspace if it exists.
+
+        If the content already starts with a markdown heading, return it as-is.
+        Otherwise wrap with a ``## Tool Usage Notes`` header.
+        """
+        tools_path = self._workspace / "TOOLS.md"
+        if not tools_path.is_file():
+            return ""
+        content = tools_path.read_text(encoding="utf-8").strip()
+        if not content:
+            return ""
+        if content.startswith("#"):
+            return content
+        return f"## Tool Usage Notes\n\n{content}"
+
+    def _build_skills_summary(self) -> str:
+        """Build nanobot-style plain text skill summary for progressive disclosure.
+
+        The LLM sees a one-line summary per skill and can call ``read_file``
+        to load the full SKILL.md when it decides the skill is relevant.
+        """
+        available = [
+            s
+            for s in self._skills
+            if hasattr(s, "mode") and s.mode == "available" and hasattr(s, "name")
+        ]
+        if not available:
+            return ""
+
+        lines = [
+            "## Available Skills",
+            "",
+            "Use read_file to load a skill's full instructions when relevant.",
+            "",
+        ]
+        for skill in available:
+            desc = getattr(skill, "description", "") or ""
+            path = getattr(skill, "source_path", "") or ""
+            # Check requirements (cache to avoid repeated shutil.which lookups)
+            if hasattr(skill, "check_requirements"):
+                cached = getattr(skill, "_cached_missing", None)
+                if cached is None:
+                    missing = skill.check_requirements()
+                    try:
+                        skill._cached_missing = missing  # type: ignore[union-attr]
+                    except (AttributeError, TypeError):
+                        pass
+                else:
+                    missing = cached
+            else:
+                missing = []
+            suffix = ""
+            if missing:
+                suffix = f" [unavailable: missing {', '.join(missing)}]"
+            elif path:
+                suffix = f" ({path})"
+            lines.append(f"- {skill.name}: {desc}{suffix}")
+        return "\n".join(lines)
+
+    def _build_agent_discovery(self) -> str:
+        """Build the Available Sub-Agents table for the default agent's context."""
+        if not self._available_agents:
+            return ""
+
+        lines = [
+            "## Available Sub-Agents",
+            "",
+            "You can delegate tasks using the `spawn` tool.",
+            "",
+            "| Agent | Description | Model | Tools | Budget |",
+            "|-------|------------|-------|-------|--------|",
+        ]
+        for name, cfg in self._available_agents.items():
+            # Skip internal agents (security) and self (default)
+            if cfg.metadata.get("internal") or name == "default":
+                continue
+            tools_str = ", ".join(cfg.tools[:4])
+            if len(cfg.tools) > 4:
+                tools_str += f" (+{len(cfg.tools) - 4})"
+            lines.append(
+                f"| {name} | {cfg.description} | {cfg.model} "
+                f"| {tools_str} | {cfg.max_iterations} iter |"
+            )
+
+        # Only return if there are non-internal, non-default agents
+        if len(lines) <= 6:  # just header, no rows
+            return ""
+        return "\n".join(lines)
+
+    def _resolve_identity_file(self, config_path: str | None, default_name: str) -> Path | None:
+        """Resolve an identity file path from config or workspace default."""
+        if config_path:
+            p = Path(config_path)
+            if p.is_absolute():
+                return p
+            return self._workspace / p
+        candidate = self._workspace / default_name
+        if candidate.is_file():
+            return candidate
+        return None