qwen-sci 0.2.2__py3-none-any.whl

src/harness/src/openharness/services/session_memory/__init__.py

@@ -0,0 +1,139 @@
+"""File-backed session memory for compact continuity."""
+
+from __future__ import annotations
+
+from hashlib import sha1
+from pathlib import Path
+
+from openharness.config.paths import get_data_dir
+from openharness.engine.messages import ConversationMessage, ToolResultBlock
+from openharness.services.token_estimation import estimate_tokens
+from openharness.utils.fs import atomic_write_text
+
+MAX_SESSION_MEMORY_CHARS = 12_000
+MAX_RECENT_LINES = 80
+
+
+def get_session_memory_dir(cwd: str | Path) -> Path:
+    """Return the project session-memory directory."""
+
+    root = Path(cwd).resolve()
+    digest = sha1(str(root).encode("utf-8")).hexdigest()[:12]
+    path = get_data_dir() / "session-memory" / f"{root.name}-{digest}"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def get_session_memory_path(cwd: str | Path, session_id: str | None = None) -> Path:
+    """Return the markdown session-memory path."""
+
+    safe_session = "".join(ch if ch.isalnum() or ch in "._-" else "_" for ch in (session_id or "default"))
+    return get_session_memory_dir(cwd) / f"{safe_session or 'default'}.md"
+
+
+def prepare_session_memory_metadata(
+    cwd: str | Path,
+    tool_metadata: dict[str, object],
+    *,
+    session_id: str | None = None,
+) -> Path:
+    """Ensure metadata points compaction to the session-memory file."""
+
+    sid = session_id or str(tool_metadata.get("session_id") or "default")
+    path = get_session_memory_path(cwd, sid)
+    tool_metadata["session_memory_path"] = str(path)
+    return path
+
+
+def get_session_memory_content(path: str | Path | None) -> str:
+    """Read session memory content if available."""
+
+    if not path:
+        return ""
+    candidate = Path(path).expanduser()
+    if not candidate.exists():
+        return ""
+    try:
+        return candidate.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+
+def update_session_memory_file(
+    cwd: str | Path,
+    messages: list[ConversationMessage],
+    *,
+    tool_metadata: dict[str, object] | None = None,
+    session_id: str | None = None,
+) -> Path:
+    """Update the deterministic session-memory checkpoint."""
+
+    path = prepare_session_memory_metadata(cwd, tool_metadata or {}, session_id=session_id)
+    body = build_session_memory_document(messages, tool_metadata=tool_metadata)
+    atomic_write_text(path, body)
+    return path
+
+
+def build_session_memory_document(
+    messages: list[ConversationMessage],
+    *,
+    tool_metadata: dict[str, object] | None = None,
+) -> str:
+    """Build a compact markdown checkpoint for the current session."""
+
+    state = tool_metadata.get("task_focus_state") if isinstance(tool_metadata, dict) else None
+    goal = ""
+    next_step = ""
+    verified: list[str] = []
+    artifacts: list[str] = []
+    if isinstance(state, dict):
+        goal = str(state.get("goal") or "").strip()
+        next_step = str(state.get("next_step") or "").strip()
+        verified = [str(item).strip() for item in state.get("verified_state", []) if str(item).strip()]
+        artifacts = [str(item).strip() for item in state.get("active_artifacts", []) if str(item).strip()]
+
+    lines = ["# Session Memory", ""]
+    lines.extend(["## Current State", goal or "(no current goal recorded)", ""])
+    if next_step:
+        lines.extend(["## Next Step", next_step, ""])
+    if verified:
+        lines.extend(["## Verified Work", *[f"- {item}" for item in verified[-10:]], ""])
+    if artifacts:
+        lines.extend(["## Active Artifacts", *[f"- {item}" for item in artifacts[-10:]], ""])
+    lines.extend(["## Recent Conversation", *_recent_message_lines(messages), ""])
+    text = "\n".join(lines).strip() + "\n"
+    if len(text) > MAX_SESSION_MEMORY_CHARS:
+        text = text[:MAX_SESSION_MEMORY_CHARS].rsplit("\n", 1)[0]
+        text += "\n\n> Session memory was truncated to stay within budget.\n"
+    return text
+
+
+def session_memory_to_compact_text(content: str) -> str:
+    """Prepare persisted session memory for insertion across compact boundaries."""
+
+    stripped = content.strip()
+    if not stripped:
+        return ""
+    if estimate_tokens(stripped) > 4_000:
+        stripped = stripped[:MAX_SESSION_MEMORY_CHARS].rsplit("\n", 1)[0]
+    return "Session memory checkpoint from earlier in this conversation:\n" + stripped
+
+
+def _recent_message_lines(messages: list[ConversationMessage]) -> list[str]:
+    lines: list[str] = []
+    for message in messages[-MAX_RECENT_LINES:]:
+        line = _summarize_message(message)
+        if line:
+            lines.append(f"- {line}")
+    return lines or ["- (no recent messages)"]
+
+
+def _summarize_message(message: ConversationMessage) -> str:
+    text = " ".join(message.text.split())
+    if text:
+        return f"{message.role}: {text[:220]}"
+    if message.tool_uses:
+        return f"{message.role}: tool calls -> {', '.join(block.name for block in message.tool_uses[:6])}"
+    if any(isinstance(block, ToolResultBlock) for block in message.content):
+        return f"{message.role}: tool results returned"
+    return f"{message.role}: [non-text content]"

src/harness/src/openharness/services/session_storage.py

@@ -0,0 +1,230 @@
+"""Session persistence helpers."""
+
+from __future__ import annotations
+
+import json
+import time
+from hashlib import sha1
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+from openharness.api.usage import UsageSnapshot
+from openharness.config.paths import get_sessions_dir
+from openharness.engine.messages import ConversationMessage, sanitize_conversation_messages
+from openharness.utils.fs import atomic_write_text
+
+
+_PERSISTED_TOOL_METADATA_KEYS = (
+    "permission_mode",
+    "read_file_state",
+    "invoked_skills",
+    "async_agent_state",
+    "async_agent_tasks",
+    "recent_work_log",
+    "recent_verified_work",
+    "task_focus_state",
+    "compact_checkpoints",
+    "compact_last",
+)
+
+
+def _sanitize_metadata(value: Any) -> Any:
+    if isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, dict):
+        return {str(key): _sanitize_metadata(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [_sanitize_metadata(item) for item in value]
+    return str(value)
+
+
+def _persistable_tool_metadata(tool_metadata: dict[str, object] | None) -> dict[str, Any]:
+    if not isinstance(tool_metadata, dict):
+        return {}
+    payload: dict[str, Any] = {}
+    for key in _PERSISTED_TOOL_METADATA_KEYS:
+        if key in tool_metadata:
+            payload[key] = _sanitize_metadata(tool_metadata[key])
+    return payload
+
+
+def get_project_session_dir(cwd: str | Path) -> Path:
+    """Return the session directory for a project."""
+    path = Path(cwd).resolve()
+    digest = sha1(str(path).encode("utf-8")).hexdigest()[:12]
+    session_dir = get_sessions_dir() / f"{path.name}-{digest}"
+    session_dir.mkdir(parents=True, exist_ok=True)
+    return session_dir
+
+
+def save_session_snapshot(
+    *,
+    cwd: str | Path,
+    model: str,
+    system_prompt: str,
+    messages: list[ConversationMessage],
+    usage: UsageSnapshot,
+    session_id: str | None = None,
+    tool_metadata: dict[str, object] | None = None,
+) -> Path:
+    """Persist a session snapshot. Saves both by ID and as latest."""
+    session_dir = get_project_session_dir(cwd)
+    sid = session_id or uuid4().hex[:12]
+    now = time.time()
+    messages = sanitize_conversation_messages(messages)
+    # Extract a summary from the first user message
+    summary = ""
+    for msg in messages:
+        if msg.role == "user" and msg.text.strip():
+            summary = msg.text.strip()[:80]
+            break
+
+    payload = {
+        "session_id": sid,
+        "cwd": str(Path(cwd).resolve()),
+        "model": model,
+        "system_prompt": system_prompt,
+        "messages": [message.model_dump(mode="json") for message in messages],
+        "usage": usage.model_dump(),
+        "tool_metadata": _persistable_tool_metadata(tool_metadata),
+        "created_at": now,
+        "summary": summary,
+        "message_count": len(messages),
+    }
+    data = json.dumps(payload, indent=2) + "\n"
+
+    # Save as latest
+    latest_path = session_dir / "latest.json"
+    atomic_write_text(latest_path, data)
+
+    # Save by session ID
+    session_path = session_dir / f"session-{sid}.json"
+    atomic_write_text(session_path, data)
+
+    return latest_path
+
+
+def _sanitize_snapshot_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    """Normalize persisted messages for forward compatibility."""
+    raw_messages = payload.get("messages", [])
+    if isinstance(raw_messages, list):
+        messages = sanitize_conversation_messages(
+            [ConversationMessage.model_validate(item) for item in raw_messages]
+        )
+        payload = dict(payload)
+        payload["messages"] = [message.model_dump(mode="json") for message in messages]
+        payload["message_count"] = len(messages)
+    return payload
+
+
+def load_session_snapshot(cwd: str | Path) -> dict[str, Any] | None:
+    """Load the most recent session snapshot for the project."""
+    path = get_project_session_dir(cwd) / "latest.json"
+    if not path.exists():
+        return None
+    return _sanitize_snapshot_payload(json.loads(path.read_text(encoding="utf-8")))
+
+
+def list_session_snapshots(cwd: str | Path, limit: int = 20) -> list[dict[str, Any]]:
+    """List saved sessions for the project, newest first."""
+    session_dir = get_project_session_dir(cwd)
+    sessions: list[dict[str, Any]] = []
+    seen_ids: set[str] = set()
+
+    # Named session files
+    for path in sorted(session_dir.glob("session-*.json"), key=lambda p: p.stat().st_mtime, reverse=True):
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            sid = data.get("session_id", path.stem.replace("session-", ""))
+            seen_ids.add(sid)
+            summary = data.get("summary", "")
+            if not summary:
+                # Extract from first user message
+                for msg in data.get("messages", []):
+                    if msg.get("role") == "user":
+                        texts = [b.get("text", "") for b in msg.get("content", []) if b.get("type") == "text"]
+                        summary = " ".join(texts).strip()[:80]
+                        if summary:
+                            break
+            sessions.append({
+                "session_id": sid,
+                "summary": summary,
+                "message_count": data.get("message_count", len(data.get("messages", []))),
+                "model": data.get("model", ""),
+                "created_at": data.get("created_at", path.stat().st_mtime),
+            })
+        except (json.JSONDecodeError, OSError):
+            continue
+        if len(sessions) >= limit:
+            break
+
+    # Also include latest.json if it has no corresponding session file
+    latest_path = session_dir / "latest.json"
+    if latest_path.exists() and len(sessions) < limit:
+        try:
+            data = json.loads(latest_path.read_text(encoding="utf-8"))
+            sid = data.get("session_id", "latest")
+            if sid not in seen_ids:
+                summary = data.get("summary", "")
+                if not summary:
+                    for msg in data.get("messages", []):
+                        if msg.get("role") == "user":
+                            texts = [b.get("text", "") for b in msg.get("content", []) if b.get("type") == "text"]
+                            summary = " ".join(texts).strip()[:80]
+                            if summary:
+                                break
+                sessions.append({
+                    "session_id": sid,
+                    "summary": summary or "(latest session)",
+                    "message_count": data.get("message_count", len(data.get("messages", []))),
+                    "model": data.get("model", ""),
+                    "created_at": data.get("created_at", latest_path.stat().st_mtime),
+                })
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    # Sort by created_at descending
+    sessions.sort(key=lambda s: s.get("created_at", 0), reverse=True)
+    return sessions[:limit]
+
+
+def load_session_by_id(cwd: str | Path, session_id: str) -> dict[str, Any] | None:
+    """Load a specific session by ID."""
+    session_dir = get_project_session_dir(cwd)
+    # Try named session first
+    path = session_dir / f"session-{session_id}.json"
+    if path.exists():
+        return _sanitize_snapshot_payload(json.loads(path.read_text(encoding="utf-8")))
+    # Fallback to latest.json if session_id matches
+    latest = session_dir / "latest.json"
+    if latest.exists():
+        data = _sanitize_snapshot_payload(json.loads(latest.read_text(encoding="utf-8")))
+        if data.get("session_id") == session_id or session_id == "latest":
+            return data
+    return None
+
+
+def export_session_markdown(
+    *,
+    cwd: str | Path,
+    messages: list[ConversationMessage],
+) -> Path:
+    """Export the session transcript as Markdown."""
+    session_dir = get_project_session_dir(cwd)
+    path = session_dir / "transcript.md"
+    parts: list[str] = ["# OpenHarness Session Transcript"]
+    for message in messages:
+        parts.append(f"\n## {message.role.capitalize()}\n")
+        text = message.text.strip()
+        if text:
+            parts.append(text)
+        for block in message.tool_uses:
+            parts.append(f"\n```tool\n{block.name} {json.dumps(block.input, ensure_ascii=True)}\n```")
+        for block in message.content:
+            if getattr(block, "type", "") == "tool_result":
+                parts.append(f"\n```tool-result\n{block.content}\n```")
+    atomic_write_text(path, "\n".join(parts).strip() + "\n")
+    return path

src/harness/src/openharness/services/token_estimation.py

@@ -0,0 +1,15 @@
+"""Simple token estimation utilities."""
+
+from __future__ import annotations
+
+
+def estimate_tokens(text: str) -> int:
+    """Estimate tokens from plain text using a rough character heuristic."""
+    if not text:
+        return 0
+    return max(1, (len(text) + 3) // 4)
+
+
+def estimate_message_tokens(messages: list[str]) -> int:
+    """Estimate tokens for a collection of message strings."""
+    return sum(estimate_tokens(message) for message in messages)

src/harness/src/openharness/services/tool_outputs.py

@@ -0,0 +1,55 @@
+"""Tool-output context budget helpers."""
+
+from __future__ import annotations
+
+import logging
+import os
+
+log = logging.getLogger(__name__)
+
+DEFAULT_TOOL_OUTPUT_INLINE_CHARS = 16_000
+DEFAULT_TOOL_OUTPUT_PREVIEW_CHARS = 3_000
+DEFAULT_MICROCOMPACT_TOOL_RESULT_CHARS = 4_000
+
+
+def _read_positive_int_env(name: str, default: int, *, minimum: int = 1) -> int:
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    try:
+        return max(minimum, int(raw))
+    except ValueError:
+        log.warning("Ignoring invalid %s=%r", name, raw)
+        return default
+
+
+def tool_output_inline_chars() -> int:
+    return _read_positive_int_env(
+        "OPENHARNESS_TOOL_OUTPUT_INLINE_CHARS",
+        DEFAULT_TOOL_OUTPUT_INLINE_CHARS,
+        minimum=256,
+    )
+
+
+def tool_output_preview_chars() -> int:
+    return _read_positive_int_env(
+        "OPENHARNESS_TOOL_OUTPUT_PREVIEW_CHARS",
+        DEFAULT_TOOL_OUTPUT_PREVIEW_CHARS,
+        minimum=128,
+    )
+
+
+def microcompact_tool_result_chars() -> int:
+    return _read_positive_int_env(
+        "OPENHARNESS_MICROCOMPACT_TOOL_RESULT_CHARS",
+        DEFAULT_MICROCOMPACT_TOOL_RESULT_CHARS,
+        minimum=256,
+    )
+
+
+def is_microcompactable_tool_result(tool_name: str, content: str) -> bool:
+    """Return True when a tool result should be eligible for old-result clearing."""
+    normalized = tool_name.strip()
+    if normalized.startswith("mcp__"):
+        return True
+    return len(content) >= microcompact_tool_result_chars()

src/harness/src/openharness/skills/__init__.py

@@ -0,0 +1,44 @@
+"""Skill exports."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover
+    from openharness.skills.registry import SkillRegistry
+    from openharness.skills.types import SkillDefinition
+
+__all__ = [
+    "SkillDefinition",
+    "SkillRegistry",
+    "discover_project_skill_dirs",
+    "get_user_skill_dirs",
+    "get_user_skills_dir",
+    "load_skill_registry",
+]
+
+
+def __getattr__(name: str):
+    if name in {"discover_project_skill_dirs", "get_user_skill_dirs", "get_user_skills_dir", "load_skill_registry"}:
+        from openharness.skills.loader import (
+            discover_project_skill_dirs,
+            get_user_skill_dirs,
+            get_user_skills_dir,
+            load_skill_registry,
+        )
+
+        return {
+            "discover_project_skill_dirs": discover_project_skill_dirs,
+            "get_user_skill_dirs": get_user_skill_dirs,
+            "get_user_skills_dir": get_user_skills_dir,
+            "load_skill_registry": load_skill_registry,
+        }[name]
+    if name == "SkillRegistry":
+        from openharness.skills.registry import SkillRegistry
+
+        return SkillRegistry
+    if name == "SkillDefinition":
+        from openharness.skills.types import SkillDefinition
+
+        return SkillDefinition
+    raise AttributeError(name)

src/harness/src/openharness/skills/_frontmatter.py

@@ -0,0 +1,97 @@
+"""Shared YAML frontmatter parsing for SKILL.md files."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+def parse_bool_frontmatter(value: Any, *, default: bool) -> bool:
+    """Parse permissive YAML frontmatter booleans."""
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return value
+    normalized = str(value).strip().lower()
+    if normalized in {"1", "true", "yes", "on"}:
+        return True
+    if normalized in {"0", "false", "no", "off"}:
+        return False
+    return default
+
+
+def optional_frontmatter_str(value: Any) -> str | None:
+    """Return a stripped string value, or ``None`` when absent/blank."""
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return None
+
+
+def parse_skill_metadata(
+    default_name: str,
+    content: str,
+    *,
+    fallback_template: str = "Skill: {name}",
+) -> dict[str, Any]:
+    """Extract metadata from a SKILL.md file.
+
+    Parses YAML frontmatter (``---`` delimited) via ``yaml.safe_load`` so that
+    folded block scalars (``>``), literal block scalars (``|``), quoted values,
+    and other standard YAML constructs are handled correctly. Falls back to
+    ``# heading`` + first body paragraph when no usable frontmatter is present,
+    and finally to ``fallback_template`` when no description can be derived.
+    """
+    name = default_name
+    description = ""
+    frontmatter: dict[str, Any] = {}
+    lines = content.splitlines()
+
+    if content.startswith("---\n"):
+        end_index = content.find("\n---\n", 4)
+        if end_index != -1:
+            try:
+                metadata = yaml.safe_load(content[4:end_index])
+                if isinstance(metadata, dict):
+                    frontmatter = metadata
+                    val = metadata.get("name")
+                    if isinstance(val, str) and val.strip():
+                        name = val.strip()
+                    val = metadata.get("description")
+                    if isinstance(val, str) and val.strip():
+                        description = val.strip()
+            except yaml.YAMLError:
+                logger.debug("Failed to parse YAML frontmatter for skill %s", default_name)
+
+    if not description:
+        for line in lines:
+            stripped = line.strip()
+            if stripped.startswith("# "):
+                if not name or name == default_name:
+                    name = stripped[2:].strip() or default_name
+                continue
+            if stripped and not stripped.startswith("---") and not stripped.startswith("#"):
+                description = stripped[:200]
+                break
+
+    if not description:
+        description = fallback_template.format(name=name)
+    return {"name": name, "description": description, "frontmatter": frontmatter}
+
+
+def parse_skill_frontmatter(
+    default_name: str,
+    content: str,
+    *,
+    fallback_template: str = "Skill: {name}",
+) -> tuple[str, str]:
+    """Extract ``name`` and ``description`` from a SKILL.md file."""
+    metadata = parse_skill_metadata(
+        default_name,
+        content,
+        fallback_template=fallback_template,
+    )
+    return str(metadata["name"]), str(metadata["description"])

src/harness/src/openharness/skills/bundled/__init__.py

@@ -0,0 +1,75 @@
+"""Bundled skill definitions loaded from .md files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from openharness.skills._frontmatter import (
+    optional_frontmatter_str,
+    parse_bool_frontmatter,
+    parse_skill_frontmatter,
+    parse_skill_metadata,
+)
+from openharness.skills.types import SkillDefinition
+
+_CONTENT_DIR = Path(__file__).parent / "content"
+
+
+def get_bundled_skills() -> list[SkillDefinition]:
+    """Load all bundled skills from the content/ directory."""
+    skills: list[SkillDefinition] = []
+    if not _CONTENT_DIR.exists():
+        return skills
+    for path in sorted(_CONTENT_DIR.glob("*.md")):
+        content = path.read_text(encoding="utf-8")
+        metadata = _parse_metadata(path.stem, content)
+        display_name = metadata["name"] if metadata["name"] != path.stem else None
+        skills.append(
+            SkillDefinition(
+                name=metadata["name"],
+                description=metadata["description"],
+                content=content,
+                source="bundled",
+                path=str(path),
+                base_dir=str(path.parent),
+                command_name=path.stem,
+                display_name=display_name,
+                user_invocable=metadata["user_invocable"],
+                disable_model_invocation=metadata["disable_model_invocation"],
+                model=metadata["model"],
+                argument_hint=metadata["argument_hint"],
+            )
+        )
+    return skills
+
+
+def _parse_frontmatter(default_name: str, content: str) -> tuple[str, str]:
+    """Extract name and description from a bundled skill markdown file.
+
+    Delegates to the shared parser so YAML block scalars (``>``, ``|``),
+    quoted values, and other standard YAML constructs are handled the same
+    way as user-installed skills.
+    """
+    return parse_skill_frontmatter(
+        default_name,
+        content,
+        fallback_template="Bundled skill: {name}",
+    )
+
+
+def _parse_metadata(default_name: str, content: str) -> dict:
+    parsed = parse_skill_metadata(default_name, content, fallback_template="Bundled skill: {name}")
+    frontmatter = parsed.get("frontmatter")
+    if not isinstance(frontmatter, dict):
+        frontmatter = {}
+    return {
+        "name": str(parsed["name"]),
+        "description": str(parsed["description"]),
+        "user_invocable": parse_bool_frontmatter(frontmatter.get("user-invocable"), default=True),
+        "disable_model_invocation": parse_bool_frontmatter(
+            frontmatter.get("disable-model-invocation"),
+            default=False,
+        ),
+        "model": optional_frontmatter_str(frontmatter.get("model")),
+        "argument_hint": optional_frontmatter_str(frontmatter.get("argument-hint")),
+    }

src/harness/src/openharness/skills/bundled/content/commit.md

@@ -0,0 +1,25 @@
+# commit
+
+Create clean, well-structured git commits.
+
+## When to use
+
+Use when the user asks to commit changes, create a PR, or prepare code for review.
+
+## Workflow
+
+1. Run `git status` and `git diff` to understand all changes
+2. Analyze changes: categorize as feature, fix, refactor, docs, test, etc.
+3. Draft a concise commit message:
+   - First line: imperative mood, under 72 chars, describes the "why"
+   - Body (if needed): explain context, trade-offs, or breaking changes
+4. Stage only relevant files — never stage .env, credentials, or large binaries
+5. Create the commit
+
+## Rules
+
+- Prefer specific `git add <file>` over `git add -A`
+- Never use `--no-verify` unless explicitly asked
+- Never amend published commits unless explicitly asked
+- If a pre-commit hook fails, fix the issue and create a NEW commit (don't --amend)
+- Include `Co-Authored-By` if pair programming