qwen-sci 0.2.2__py3-none-any.whl

src/harness/src/openharness/memory/usage.py

@@ -0,0 +1,153 @@
+"""Usage index for recalled memory entries."""
+
+from __future__ import annotations
+
+import json
+from datetime import timedelta
+from pathlib import Path
+from typing import Any
+
+from openharness.memory.paths import get_project_memory_dir
+from openharness.memory.scan import scan_memory_files
+from openharness.memory.schema import format_datetime, parse_datetime, utc_now
+from openharness.memory.types import MemoryHeader
+from openharness.utils.file_lock import exclusive_file_lock
+from openharness.utils.fs import atomic_write_text
+
+USAGE_INDEX_NAME = "usage_index.json"
+STALE_UNUSED_DAYS = 60
+STALE_MAX_IMPORTANCE = 1
+
+
+def get_usage_index_path(cwd: str | Path, *, memory_dir: str | Path | None = None) -> Path:
+    """Return the usage index path for a memory store."""
+
+    root = Path(memory_dir) if memory_dir is not None else get_project_memory_dir(cwd)
+    root.mkdir(parents=True, exist_ok=True)
+    return root / USAGE_INDEX_NAME
+
+
+def load_usage_index(cwd: str | Path, *, memory_dir: str | Path | None = None) -> dict[str, Any]:
+    """Load usage index data, returning an empty index for invalid files."""
+
+    path = get_usage_index_path(cwd, memory_dir=memory_dir)
+    if not path.exists():
+        return _empty_index()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return _empty_index()
+    if not isinstance(data, dict):
+        return _empty_index()
+    memories = data.get("memories")
+    if not isinstance(memories, dict):
+        memories = {}
+    normalized = _empty_index()
+    normalized["memories"] = {
+        str(memory_id): _normalize_usage_record(record)
+        for memory_id, record in memories.items()
+        if isinstance(record, dict)
+    }
+    return normalized
+
+
+def save_usage_index(
+    cwd: str | Path,
+    index: dict[str, Any],
+    *,
+    memory_dir: str | Path | None = None,
+) -> None:
+    """Persist usage index data atomically."""
+
+    path = get_usage_index_path(cwd, memory_dir=memory_dir)
+    payload = json.dumps(index, indent=2, ensure_ascii=False, sort_keys=True) + "\n"
+    atomic_write_text(path, payload)
+
+
+def get_memory_usage(
+    cwd: str | Path,
+    memory_id: str,
+    *,
+    memory_dir: str | Path | None = None,
+) -> dict[str, Any]:
+    """Return usage data for a memory id."""
+
+    if not memory_id:
+        return _normalize_usage_record({})
+    index = load_usage_index(cwd, memory_dir=memory_dir)
+    record = index["memories"].get(memory_id, {})
+    return _normalize_usage_record(record)
+
+
+def mark_memory_used(
+    cwd: str | Path,
+    memories: list[MemoryHeader],
+    *,
+    memory_dir: str | Path | None = None,
+) -> None:
+    """Record that memory entries were recalled into a runtime prompt."""
+
+    usable = [header for header in memories if header.id]
+    if not usable:
+        return
+    resolved_memory_dir = Path(memory_dir) if memory_dir is not None else usable[0].path.parent
+    lock_path = resolved_memory_dir / ".usage_index.lock"
+    with exclusive_file_lock(lock_path):
+        index = load_usage_index(cwd, memory_dir=resolved_memory_dir)
+        now = format_datetime(utc_now())
+        for header in usable:
+            record = _normalize_usage_record(index["memories"].get(header.id, {}))
+            record["use_count"] = int(record["use_count"]) + 1
+            record["last_used_at"] = now
+            record["path"] = header.path.name
+            index["memories"][header.id] = record
+        save_usage_index(cwd, index, memory_dir=resolved_memory_dir)
+
+
+def find_stale_memory_candidates(
+    cwd: str | Path,
+    *,
+    memory_dir: str | Path | None = None,
+) -> list[MemoryHeader]:
+    """Return low-value unused memories that auto-dream should review for pruning."""
+
+    resolved_memory_dir = Path(memory_dir) if memory_dir is not None else None
+    headers = scan_memory_files(
+        cwd,
+        max_files=None,
+        include_disabled=False,
+        include_expired=False,
+        memory_dir=resolved_memory_dir,
+    )
+    now = utc_now()
+    candidates: list[MemoryHeader] = []
+    for header in headers:
+        if header.importance > STALE_MAX_IMPORTANCE:
+            continue
+        usage = get_memory_usage(cwd, header.id, memory_dir=resolved_memory_dir or header.path.parent)
+        if int(usage["use_count"]) > 0:
+            continue
+        updated_at = parse_datetime(header.updated_at) or parse_datetime(header.created_at)
+        if updated_at is None:
+            continue
+        if now - updated_at >= timedelta(days=STALE_UNUSED_DAYS):
+            candidates.append(header)
+    candidates.sort(key=lambda item: (item.importance, item.updated_at or "", item.path.name))
+    return candidates
+
+
+def _empty_index() -> dict[str, Any]:
+    return {"version": 1, "memories": {}}
+
+
+def _normalize_usage_record(record: dict[str, Any]) -> dict[str, Any]:
+    use_count = record.get("use_count", 0)
+    try:
+        use_count = max(0, int(use_count))
+    except (TypeError, ValueError):
+        use_count = 0
+    return {
+        "last_used_at": str(record.get("last_used_at") or ""),
+        "use_count": use_count,
+        "path": str(record.get("path") or ""),
+    }

src/harness/src/openharness/output_styles/__init__.py

@@ -0,0 +1,5 @@
+"""Output styles exports."""
+
+from openharness.output_styles.loader import OutputStyle, get_output_styles_dir, load_output_styles
+
+__all__ = ["OutputStyle", "get_output_styles_dir", "load_output_styles"]

src/harness/src/openharness/output_styles/loader.py

@@ -0,0 +1,42 @@
+"""Output style loading."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from openharness.config.paths import get_config_dir
+
+
+@dataclass(frozen=True)
+class OutputStyle:
+    """A named output style."""
+
+    name: str
+    content: str
+    source: str
+
+
+def get_output_styles_dir() -> Path:
+    """Return the custom output styles directory."""
+    path = get_config_dir() / "output_styles"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def load_output_styles() -> list[OutputStyle]:
+    """Load bundled and custom output styles."""
+    styles = [
+        OutputStyle(name="default", content="Standard rich console output.", source="builtin"),
+        OutputStyle(name="minimal", content="Very terse plain-text output.", source="builtin"),
+        OutputStyle(name="codex", content="Codex-like compact transcript and tool output.", source="builtin"),
+    ]
+    for path in sorted(get_output_styles_dir().glob("*.md")):
+        styles.append(
+            OutputStyle(
+                name=path.stem,
+                content=path.read_text(encoding="utf-8"),
+                source="user",
+            )
+        )
+    return styles

src/harness/src/openharness/permissions/__init__.py

@@ -0,0 +1,26 @@
+"""Permission helpers for OpenHarness."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover
+    from openharness.permissions.checker import PermissionChecker, PermissionDecision
+    from openharness.permissions.modes import PermissionMode
+
+__all__ = ["PermissionChecker", "PermissionDecision", "PermissionMode"]
+
+
+def __getattr__(name: str):
+    if name in {"PermissionChecker", "PermissionDecision"}:
+        from openharness.permissions.checker import PermissionChecker, PermissionDecision
+
+        return {
+            "PermissionChecker": PermissionChecker,
+            "PermissionDecision": PermissionDecision,
+        }[name]
+    if name == "PermissionMode":
+        from openharness.permissions.modes import PermissionMode
+
+        return PermissionMode
+    raise AttributeError(name)

src/harness/src/openharness/permissions/checker.py

@@ -0,0 +1,200 @@
+"""Permission checking for tool execution."""
+
+from __future__ import annotations
+
+import fnmatch
+import logging
+from dataclasses import dataclass
+
+from openharness.config.settings import PermissionSettings
+from openharness.permissions.modes import PermissionMode
+
+log = logging.getLogger(__name__)
+
+# Paths that are always denied regardless of permission mode or user config.
+# These protect high-value credential and key material from LLM-directed access
+# (including via prompt injection).  Patterns use fnmatch syntax and are matched
+# against the fully-resolved absolute path produced by the query engine.
+SENSITIVE_PATH_PATTERNS: tuple[str, ...] = (
+    # SSH keys and config
+    "*/.ssh/*",
+    # AWS credentials
+    "*/.aws/credentials",
+    "*/.aws/config",
+    # GCP credentials
+    "*/.config/gcloud/*",
+    # Azure credentials
+    "*/.azure/*",
+    # GPG keys
+    "*/.gnupg/*",
+    # Docker credentials
+    "*/.docker/config.json",
+    # Kubernetes credentials
+    "*/.kube/config",
+    # OpenHarness own credential stores
+    "*/.openharness/credentials.json",
+    "*/.openharness/copilot_auth.json",
+)
+
+
+@dataclass(frozen=True)
+class PermissionDecision:
+    """Result of checking whether a tool invocation may run."""
+
+    allowed: bool
+    requires_confirmation: bool = False
+    reason: str = ""
+
+
+@dataclass(frozen=True)
+class PathRule:
+    """A glob-based path permission rule."""
+
+    pattern: str
+    allow: bool  # True = allow, False = deny
+
+
+class PermissionChecker:
+    """Evaluate tool usage against the configured permission mode and rules."""
+
+    def __init__(self, settings: PermissionSettings) -> None:
+        self._settings = settings
+        # Parse path rules from settings
+        self._path_rules: list[PathRule] = []
+        for rule in getattr(settings, "path_rules", []):
+            pattern = getattr(rule, "pattern", None) or (rule.get("pattern") if isinstance(rule, dict) else None)
+            allow = getattr(rule, "allow", True) if not isinstance(rule, dict) else rule.get("allow", True)
+            if isinstance(pattern, str) and pattern.strip():
+                self._path_rules.append(PathRule(pattern=pattern.strip(), allow=allow))
+            else:
+                log.warning(
+                    "Skipping path rule with missing, empty, or non-string 'pattern' field: %r",
+                    rule,
+                )
+
+    def evaluate(
+        self,
+        tool_name: str,
+        *,
+        is_read_only: bool,
+        file_path: str | None = None,
+        command: str | None = None,
+    ) -> PermissionDecision:
+        """Return whether the tool may run immediately."""
+        # Built-in sensitive path protection — always active, cannot be
+        # overridden by user settings or permission mode.  This is a
+        # defence-in-depth measure against LLM-directed or prompt-injection
+        # driven access to credential files.
+        if file_path:
+            for candidate_path in _policy_match_paths(file_path):
+                for pattern in SENSITIVE_PATH_PATTERNS:
+                    if fnmatch.fnmatch(candidate_path, pattern):
+                        return PermissionDecision(
+                            allowed=False,
+                            reason=(
+                                f"Access denied: {file_path} is a sensitive credential path "
+                                f"(matched built-in pattern '{pattern}')"
+                            ),
+                        )
+
+        # Explicit tool deny list
+        if tool_name in self._settings.denied_tools:
+            return PermissionDecision(allowed=False, reason=f"{tool_name} is explicitly denied")
+
+        # Explicit tool allow list
+        if tool_name in self._settings.allowed_tools:
+            return PermissionDecision(allowed=True, reason=f"{tool_name} is explicitly allowed")
+
+        # Check path-level rules
+        if file_path and self._path_rules:
+            for candidate_path in _policy_match_paths(file_path):
+                for rule in self._path_rules:
+                    if fnmatch.fnmatch(candidate_path, rule.pattern):
+                        if not rule.allow:
+                            return PermissionDecision(
+                                allowed=False,
+                                reason=f"Path {file_path} matches deny rule: {rule.pattern}",
+                            )
+
+        # Check command deny patterns (e.g. deny "rm -rf /")
+        if command:
+            for pattern in getattr(self._settings, "denied_commands", []):
+                if isinstance(pattern, str) and fnmatch.fnmatch(command, pattern):
+                    return PermissionDecision(
+                        allowed=False,
+                        reason=f"Command matches deny pattern: {pattern}",
+                    )
+
+        # Full auto: allow everything
+        if self._settings.mode == PermissionMode.FULL_AUTO:
+            return PermissionDecision(allowed=True, reason="Auto mode allows all tools")
+
+        # Read-only tools always allowed
+        if is_read_only:
+            return PermissionDecision(allowed=True, reason="read-only tools are allowed")
+
+        # Plan mode: block mutating tools
+        if self._settings.mode == PermissionMode.PLAN:
+            return PermissionDecision(
+                allowed=False,
+                reason="Plan mode blocks mutating tools until the user exits plan mode",
+            )
+
+        # Default mode: require confirmation for mutating tools
+        bash_hint = _bash_permission_hint(command)
+        reason = (
+            "Mutating tools require user confirmation in default mode. "
+            "Approve the prompt when asked, or run /permissions full_auto "
+            "if you want to allow them for this session."
+        )
+        if bash_hint:
+            reason = f"{reason} {bash_hint}"
+        return PermissionDecision(
+            allowed=False,
+            requires_confirmation=True,
+            reason=reason,
+        )
+
+
+def _policy_match_paths(file_path: str) -> tuple[str, ...]:
+    """Return path forms that should participate in policy matching.
+
+    Directory-scoped tools like ``grep`` and ``glob`` may operate on a root such
+    as ``/home/user/.ssh``. Appending a trailing slash lets glob-style deny
+    patterns like ``*/.ssh/*`` and ``/etc/*`` match the directory root itself.
+    """
+    normalized = file_path.rstrip("/")
+    if not normalized:
+        return (file_path,)
+    return (normalized, normalized + "/")
+
+
+def _bash_permission_hint(command: str | None) -> str:
+    if not command:
+        return ""
+    lowered = command.lower()
+    install_markers = (
+        "npm install",
+        "pnpm install",
+        "yarn install",
+        "bun install",
+        "pip install",
+        "uv pip install",
+        "poetry install",
+        "cargo install",
+        "create-next-app",
+        "npm create ",
+        "pnpm create ",
+        "yarn create ",
+        "bun create ",
+        "npx create-",
+        "npm init ",
+        "pnpm init ",
+        "yarn init ",
+    )
+    if any(marker in lowered for marker in install_markers):
+        return (
+            "Package installation and scaffolding commands change the workspace, "
+            "so they will not run automatically in default mode."
+        )
+    return ""

src/harness/src/openharness/permissions/modes.py

@@ -0,0 +1,13 @@
+"""Permission mode definitions."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class PermissionMode(str, Enum):
+    """Supported permission modes."""
+
+    DEFAULT = "default"
+    PLAN = "plan"
+    FULL_AUTO = "full_auto"

src/harness/src/openharness/personalization/__init__.py

@@ -0,0 +1,6 @@
+"""Session personalization — auto-extract local rules from conversation history."""
+
+from openharness.personalization.extractor import extract_local_rules
+from openharness.personalization.rules import load_local_rules, save_local_rules
+
+__all__ = ["extract_local_rules", "load_local_rules", "save_local_rules"]

src/harness/src/openharness/personalization/extractor.py

@@ -0,0 +1,138 @@
+"""Extract local rules from session conversation history."""
+
+from __future__ import annotations
+
+import logging
+import re
+
+log = logging.getLogger(__name__)
+
+# Patterns that indicate environment-specific facts worth capturing
+_FACT_PATTERNS: list[tuple[str, str, re.Pattern]] = [
+    ("ssh_host", "SSH connection", re.compile(
+        r"ssh\s+(?:-[io]\s+\S+\s+)*(\S+@[\d.]+|\S+@\S+)", re.IGNORECASE
+    )),
+    ("ip_address", "Server IP", re.compile(
+        r"(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})"
+    )),
+    ("data_path", "Data path", re.compile(
+        r"(/(?:ext|mnt|home|data|root)\S*/(?:data\S*|landing|derived|reference)\S*)"
+    )),
+    ("conda_env", "Conda environment", re.compile(
+        r"conda\s+activate\s+(\S+)"
+    )),
+    ("python_env", "Python version", re.compile(
+        r"[Pp]ython\s*(3\.\d+(?:\.\d+)?)"
+    )),
+    ("api_endpoint", "API endpoint", re.compile(
+        r"(https?://\S+/v\d+/?)\b"
+    )),
+    ("env_var", "Environment variable", re.compile(
+        r"export\s+([A-Z][A-Z0-9_]+)(?:=\S+)?"
+    )),
+    ("git_remote", "Git remote", re.compile(
+        r"(?:github|gitlab)\.com[:/](\S+?)(?:\.git)?"
+    )),
+    ("ray_cluster", "Ray cluster", re.compile(
+        r"ray\s+(?:start|init|submit)\b.*?(--address\s+\S+|\d+\.\d+\.\d+\.\d+:\d+)",
+        re.IGNORECASE,
+    )),
+    ("cron_schedule", "Cron schedule", re.compile(
+        r"((?:\d+|\*)\s+(?:\d+|\*)\s+(?:\d+|\*)\s+(?:\d+|\*)\s+(?:\d+|\*))\s+\S+"
+    )),
+]
+
+
+def extract_facts_from_text(text: str) -> list[dict]:
+    """Extract environment-specific facts from conversation text using patterns."""
+    facts = []
+    seen_keys = set()
+
+    for fact_type, label, pattern in _FACT_PATTERNS:
+        for match in pattern.finditer(text):
+            value = match.group(1) if match.lastindex else match.group(0)
+            value = value.strip().rstrip(".,;:)")
+            if not value or len(value) < 3:
+                continue
+
+            # Skip common false positives
+            if fact_type == "ip_address" and value.startswith(("0.", "255.", "127.0.0.1")):
+                continue
+
+            key = f"{fact_type}:{value}"
+            if key in seen_keys:
+                continue
+            seen_keys.add(key)
+
+            facts.append({
+                "key": key,
+                "type": fact_type,
+                "label": label,
+                "value": value,
+                "confidence": 0.7,
+            })
+
+    return facts
+
+
+def extract_local_rules(session_messages: list[dict]) -> list[dict]:
+    """Extract environment facts from a list of session messages.
+
+    Args:
+        session_messages: List of message dicts with 'role' and 'content' keys.
+
+    Returns:
+        List of fact dicts with key, type, label, value, confidence.
+    """
+    all_text = []
+    for msg in session_messages:
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            all_text.append(content)
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict) and "text" in block:
+                    all_text.append(block["text"])
+
+    combined = "\n".join(all_text)
+    return extract_facts_from_text(combined)
+
+
+def facts_to_rules_markdown(facts: list[dict]) -> str:
+    """Convert extracted facts to a markdown rules document."""
+    if not facts:
+        return ""
+
+    grouped: dict[str, list[dict]] = {}
+    for f in facts:
+        grouped.setdefault(f["type"], []).append(f)
+
+    lines = [
+        "# Local Environment Rules",
+        "",
+        "*Auto-generated from session history. Do not edit manually.*",
+        "",
+    ]
+
+    section_titles = {
+        "ssh_host": "SSH Hosts",
+        "ip_address": "Known Servers",
+        "data_path": "Data Paths",
+        "conda_env": "Python Environments",
+        "python_env": "Python Versions",
+        "api_endpoint": "API Endpoints",
+        "env_var": "Environment Variables",
+        "git_remote": "Git Repositories",
+        "ray_cluster": "Ray Cluster Config",
+        "cron_schedule": "Scheduled Jobs",
+    }
+
+    for fact_type, items in grouped.items():
+        title = section_titles.get(fact_type, fact_type.replace("_", " ").title())
+        lines.append(f"## {title}")
+        lines.append("")
+        for item in items:
+            lines.append(f"- `{item['value']}`")
+        lines.append("")
+
+    return "\n".join(lines)

src/harness/src/openharness/personalization/rules.py

@@ -0,0 +1,64 @@
+"""Local rules file management."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+_RULES_DIR = Path("~/.openharness/local_rules").expanduser()
+_RULES_FILE = _RULES_DIR / "rules.md"
+_FACTS_FILE = _RULES_DIR / "facts.json"
+
+
+def _ensure_dir() -> None:
+    _RULES_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_local_rules() -> str:
+    """Load the local rules markdown, or empty string if none exist."""
+    if _RULES_FILE.exists():
+        return _RULES_FILE.read_text(encoding="utf-8").strip()
+    return ""
+
+
+def save_local_rules(content: str) -> Path:
+    """Write local rules markdown."""
+    _ensure_dir()
+    _RULES_FILE.write_text(content.strip() + "\n", encoding="utf-8")
+    return _RULES_FILE
+
+
+def load_facts() -> dict:
+    """Load extracted facts as a dict."""
+    if _FACTS_FILE.exists():
+        return json.loads(_FACTS_FILE.read_text(encoding="utf-8"))
+    return {"facts": [], "last_updated": None}
+
+
+def save_facts(facts: dict) -> None:
+    """Persist extracted facts."""
+    _ensure_dir()
+    facts["last_updated"] = datetime.now(timezone.utc).isoformat()
+    _FACTS_FILE.write_text(
+        json.dumps(facts, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def merge_facts(existing: dict, new_facts: list[dict]) -> dict:
+    """Merge new facts into existing, deduplicating by key."""
+    by_key = {}
+    for f in existing.get("facts", []):
+        by_key[f["key"]] = f
+    for f in new_facts:
+        key = f.get("key", "")
+        if key:
+            if key in by_key:
+                # Update with newer value, keep higher confidence
+                old = by_key[key]
+                if f.get("confidence", 0) >= old.get("confidence", 0):
+                    by_key[key] = f
+            else:
+                by_key[key] = f
+    return {"facts": list(by_key.values())}