windcode 0.1.0__py3-none-any.whl

windcode/config/writer.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+from typing import Any, cast
+from uuid import uuid4
+
+import tomli_w
+
+from windcode.config.models import AppConfig
+
+
+def _read_config(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    with path.open("rb") as stream:
+        value = tomllib.load(stream)
+    return value
+
+
+def save_model_config(path: Path, previous: AppConfig, updated: AppConfig) -> None:
+    """Persist model profiles without storing API key values."""
+    path = path.expanduser().resolve()
+    data = _read_config(path)
+    raw_disabled = data.get("disabled_providers", [])
+    disabled: set[str] = set()
+    if isinstance(raw_disabled, list):
+        disabled = {str(alias) for alias in cast(list[object], raw_disabled)}
+    disabled.update(previous.providers.keys() - updated.providers.keys())
+    disabled.difference_update(updated.providers)
+
+    data["providers"] = {
+        alias: provider.model_dump(mode="json", exclude_none=True)
+        for alias, provider in updated.providers.items()
+    }
+    if updated.primary_provider is None:
+        data.pop("primary_provider", None)
+    else:
+        data["primary_provider"] = updated.primary_provider
+    data["fallback_chain"] = list(updated.fallback_chain)
+    data["enabled_providers"] = sorted(updated.providers)
+    if disabled:
+        data["disabled_providers"] = sorted(disabled)
+    else:
+        data.pop("disabled_providers", None)
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(f"{path.suffix}.tmp-{uuid4().hex}")
+    try:
+        with temporary.open("wb") as stream:
+            tomli_w.dump(data, stream)
+            stream.flush()
+            os.fsync(stream.fileno())
+        temporary.replace(path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def save_memory_config(path: Path, config: AppConfig) -> None:
+    """Persist non-secret memory policy without rewriting unrelated configuration."""
+    path = path.expanduser().resolve()
+    data = _read_config(path)
+    data["memory"] = config.memory.model_dump(mode="json", exclude_none=True)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(f"{path.suffix}.tmp-{uuid4().hex}")
+    try:
+        with temporary.open("wb") as stream:
+            tomli_w.dump(data, stream)
+            stream.flush()
+            os.fsync(stream.fileno())
+        temporary.replace(path)
+    finally:
+        temporary.unlink(missing_ok=True)

windcode/context/__init__.py

@@ -0,0 +1,18 @@
+from windcode.context.compactor import (
+    CHECKPOINT_SECTIONS,
+    CompactionResult,
+    compact_context,
+)
+from windcode.context.estimator import ContextBudget, TokenEstimator, estimate_message_tokens
+from windcode.context.truncation import TruncationResult, truncate_context
+
+__all__ = [
+    "CHECKPOINT_SECTIONS",
+    "CompactionResult",
+    "ContextBudget",
+    "TokenEstimator",
+    "TruncationResult",
+    "compact_context",
+    "estimate_message_tokens",
+    "truncate_context",
+]

windcode/context/compactor.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from windcode.domain.messages import Message, Role, TextBlock
+from windcode.domain.models import ModelRequest, TextDelta
+from windcode.providers.base import ModelTransport
+
+CHECKPOINT_SECTIONS = (
+    "任务目标",
+    "关键决策",
+    "相关文件",
+    "当前进度",
+    "未完成事项",
+    "验证证据",
+    "约束与指令",
+    "下一步",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CompactionResult:
+    messages: tuple[Message, ...]
+    checkpoint: str | None
+    error: str | None = None
+
+    @property
+    def compacted(self) -> bool:
+        return self.checkpoint is not None
+
+
+def checkpoint_prompt() -> str:
+    sections = "\n".join(f"## {section}\n[简明, 具体, 无遗漏]" for section in CHECKPOINT_SECTIONS)
+    return f"请根据完整对话生成结构化检查点. 必须准确记录已验证证据, 不要推测成功.\n\n{sections}"
+
+
+def _valid_checkpoint(text: str) -> bool:
+    return all(f"## {section}" in text for section in CHECKPOINT_SECTIONS)
+
+
+async def compact_context(
+    messages: tuple[Message, ...],
+    transport: ModelTransport,
+    *,
+    model: str,
+    system_prompt: str,
+    preserve_recent_turns: int = 8,
+) -> CompactionResult:
+    request = ModelRequest(
+        model=model,
+        messages=(*messages, Message(Role.USER, (TextBlock(checkpoint_prompt()),))),
+        system_prompt=system_prompt,
+    )
+    parts: list[str] = []
+    try:
+        async for event in transport.stream(request):
+            if isinstance(event, TextDelta):
+                parts.append(event.text)
+    except Exception as exc:
+        return CompactionResult(messages, None, f"checkpoint generation failed: {exc}")
+    checkpoint = "".join(parts).strip()
+    if not _valid_checkpoint(checkpoint):
+        return CompactionResult(messages, None, "checkpoint response is missing required sections")
+
+    system_messages = tuple(message for message in messages if message.role is Role.SYSTEM)
+    non_system = tuple(message for message in messages if message.role is not Role.SYSTEM)
+    recent = non_system[-preserve_recent_turns * 2 :]
+    checkpoint_message = Message(
+        Role.SYSTEM,
+        (TextBlock(f"上下文检查点:\n{checkpoint}"),),
+    )
+    return CompactionResult((*system_messages, checkpoint_message, *recent), checkpoint)

windcode/context/estimator.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+from windcode.domain.messages import (
+    Message,
+    ReasoningBlock,
+    TextBlock,
+    ToolCallBlock,
+    ToolResultBlock,
+)
+from windcode.domain.models import ModelRequest, Usage
+
+
+def estimate_text_tokens(text: str) -> int:
+    if not text:
+        return 0
+    return max(1, math.ceil(len(text.encode("utf-8")) / 4))
+
+
+def estimate_message_tokens(message: Message) -> int:
+    tokens = 4
+    for block in message.content:
+        if isinstance(block, TextBlock):
+            tokens += estimate_text_tokens(block.text)
+        elif isinstance(block, ReasoningBlock):
+            tokens += estimate_text_tokens(block.summary)
+        elif isinstance(block, ToolCallBlock):
+            tokens += estimate_text_tokens(block.name) + estimate_text_tokens(str(block.arguments))
+        elif isinstance(block, ToolResultBlock):
+            tokens += estimate_text_tokens(block.content)
+        else:
+            tokens += 256
+    return tokens
+
+
+@dataclass(frozen=True, slots=True)
+class ContextBudget:
+    estimated_tokens: int
+    compaction_at: int
+    reserved_output_tokens: int
+    remaining_tokens: int
+    should_compact: bool
+
+
+class TokenEstimator:
+    def __init__(
+        self,
+        window_tokens: int,
+        *,
+        compaction_threshold: float = 0.8,
+        reserved_output_tokens: int = 4_096,
+    ) -> None:
+        if window_tokens <= reserved_output_tokens:
+            raise ValueError("context window must exceed the reserved output budget")
+        if not 0 < compaction_threshold < 1:
+            raise ValueError("compaction threshold must be between zero and one")
+        self.window_tokens = window_tokens
+        self.compaction_threshold = compaction_threshold
+        self.reserved_output_tokens = reserved_output_tokens
+
+    def estimate(
+        self,
+        request: ModelRequest,
+        *,
+        actual_usage: Usage | None = None,
+        incremental_text: str = "",
+    ) -> ContextBudget:
+        estimated = (
+            actual_usage.input_tokens
+            if actual_usage is not None and actual_usage.input_tokens > 0
+            else estimate_text_tokens(request.system_prompt)
+            + sum(estimate_message_tokens(message) for message in request.messages)
+            + sum(estimate_text_tokens(str(tool.parameters)) + 8 for tool in request.tools)
+        )
+        estimated += estimate_text_tokens(incremental_text)
+        compaction_at = min(
+            int(self.window_tokens * self.compaction_threshold),
+            self.window_tokens - self.reserved_output_tokens,
+        )
+        remaining = max(0, self.window_tokens - self.reserved_output_tokens - estimated)
+        return ContextBudget(
+            estimated_tokens=estimated,
+            compaction_at=compaction_at,
+            reserved_output_tokens=self.reserved_output_tokens,
+            remaining_tokens=remaining,
+            should_compact=estimated >= compaction_at,
+        )

windcode/context/truncation.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+
+from windcode.domain.messages import (
+    AttachmentBlock,
+    ContentBlock,
+    Message,
+    Role,
+    ToolCallBlock,
+    ToolResultBlock,
+)
+from windcode.sessions import ArtifactReference, ArtifactStore
+
+
+@dataclass(frozen=True, slots=True)
+class TruncationResult:
+    messages: tuple[Message, ...]
+    artifacts: tuple[ArtifactReference, ...]
+    removed_attachments: int
+    changed: bool
+
+
+def _recent_cutoff(messages: tuple[Message, ...], preserve_recent_turns: int) -> int:
+    user_indexes = [index for index, message in enumerate(messages) if message.role is Role.USER]
+    if len(user_indexes) <= preserve_recent_turns:
+        return 0
+    return user_indexes[-preserve_recent_turns]
+
+
+def truncate_context(
+    messages: tuple[Message, ...],
+    artifact_store: ArtifactStore,
+    *,
+    max_tool_result_chars: int = 20_000,
+    preserve_recent_turns: int = 8,
+) -> TruncationResult:
+    cutoff = _recent_cutoff(messages, preserve_recent_turns)
+    completed_calls = {
+        block.call_id
+        for message in messages
+        for block in message.content
+        if isinstance(block, ToolResultBlock)
+    }
+    open_calls = {
+        block.call_id
+        for message in messages
+        for block in message.content
+        if isinstance(block, ToolCallBlock) and block.call_id not in completed_calls
+    }
+    artifacts: list[ArtifactReference] = []
+    removed = 0
+    changed = False
+    transformed: list[Message] = []
+    for index, message in enumerate(messages):
+        protected = (
+            index >= cutoff
+            or message.role is Role.SYSTEM
+            or any(
+                isinstance(block, ToolCallBlock) and block.call_id in open_calls
+                for block in message.content
+            )
+        )
+        content: list[ContentBlock] = []
+        for block in message.content:
+            if isinstance(block, AttachmentBlock) and not protected:
+                removed += 1
+                changed = True
+                continue
+            if (
+                isinstance(block, ToolResultBlock)
+                and not protected
+                and len(block.content) > max_tool_result_chars
+            ):
+                summary, reference = artifact_store.externalize(
+                    block.content, threshold=max_tool_result_chars
+                )
+                if reference is not None:
+                    artifacts.append(reference)
+                    content.append(
+                        replace(block, content=summary, artifact_ref=reference.relative_path)
+                    )
+                    changed = True
+                    continue
+            content.append(block)
+        transformed.append(replace(message, content=tuple(content)))
+    return TruncationResult(tuple(transformed), tuple(artifacts), removed, changed)

windcode/domain/__init__.py

@@ -0,0 +1 @@
+"""Dependency-free domain contracts."""

windcode/domain/errors.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class ErrorCategory(StrEnum):
+    AUTHENTICATION = "authentication"
+    RATE_LIMIT = "rate_limit"
+    NETWORK = "network"
+    SERVER = "server"
+    CONTEXT_OVERFLOW = "context_overflow"
+    INVALID_REQUEST = "invalid_request"
+    CONTENT_POLICY = "content_policy"
+    CANCELLED = "cancelled"
+    INTERNAL = "internal"
+
+
+_RETRYABLE = {ErrorCategory.RATE_LIMIT, ErrorCategory.NETWORK, ErrorCategory.SERVER}
+_FALLBACK_ALLOWED = _RETRYABLE | {ErrorCategory.CONTEXT_OVERFLOW}
+
+
+class WindcodeError(Exception):
+    def __init__(self, message: str, category: ErrorCategory = ErrorCategory.INTERNAL) -> None:
+        super().__init__(message)
+        self.category = category
+
+    @property
+    def retryable(self) -> bool:
+        return self.category in _RETRYABLE
+
+    @property
+    def fallback_allowed(self) -> bool:
+        return self.category in _FALLBACK_ALLOWED