pascal-agent 0.3.0__py3-none-any.whl

pascal/effect.py

@@ -0,0 +1,155 @@
+"""Effect Ladder -- classify and gate action side effects.
+
+Hard-rules only:
+1. Hard patterns: commands that are ALWAYS a specific level (regex-based).
+2. Safe commands: explicitly classified as E0 (read-only).
+3. Fallback: unrecognized commands default to E2 (conservative).
+LLM self-reported effect_level is ignored.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+
+EFFECT_LEVELS = {
+    "E0": "observe",
+    "E1": "transform",
+    "E2": "draft",
+    "E3": "stage",
+    "E4": "commit",
+    "E5": "irreversible",
+}
+
+DEFAULT_MAX_EFFECT = "E2"
+
+_HARD_RULES: list[tuple[str, re.Pattern]] = [
+    # E5 -- irreversible
+    ("E5", re.compile(r"\brm\b\s+.*-[rRf]", re.I)),
+    ("E5", re.compile(r"\brm\b\s+-[rRf]", re.I)),
+    ("E5", re.compile(r"\bsudo\b")),
+    ("E5", re.compile(r"\bmkfs\b")),
+    ("E5", re.compile(r"\bshutdown\b")),
+    ("E5", re.compile(r"\breboot\b")),
+    ("E5", re.compile(r"\bdd\b\s+.*of=")),
+    ("E5", re.compile(r"\bdrop\s+(table|database)\b", re.I)),
+    ("E5", re.compile(r"\btruncate\s+table\b", re.I)),
+    ("E5", re.compile(r"\bchmod\b.*777")),
+    ("E5", re.compile(r"\bkubectl\s+delete\b")),
+    ("E5", re.compile(r"\bformat\s+[a-z]:", re.I)),
+    # E5 -- Windows irreversible
+    ("E5", re.compile(r"\brd\s+/s\s+/q\b", re.I)),
+    ("E5", re.compile(r"\bdel\s+/[sfq]", re.I)),
+    ("E5", re.compile(r"\bRemove-Item\b.*-Recurse", re.I)),
+    # E5 -- shell wrappers hiding arbitrary commands
+    ("E5", re.compile(r"\bpowershell\b.*-(?:e|EncodedCommand)\s", re.I)),
+    ("E5", re.compile(r"\bcmd\s+/c\s+.*(?:del|rd|format)\b", re.I)),
+    # E4 -- real external writes
+    ("E4", re.compile(r"\bgit\s+push\s+.*(?:main|master)\b")),
+    ("E4", re.compile(r"\bgit\s+merge\b")),
+    ("E4", re.compile(r"\bgh\s+pr\s+merge\b")),
+    ("E4", re.compile(r"\bgh\s+issue\s+(?:edit|close|delete)\b")),
+    ("E4", re.compile(r"\bcurl\b.*-X\s*(?:POST|PUT|DELETE|PATCH)", re.I)),
+    ("E4", re.compile(r"\bcurl\b.*--request\s+(?:POST|PUT|DELETE|PATCH)", re.I)),
+    ("E4", re.compile(r"\bcurl\b.*(?:-d\s|--data)", re.I)),
+    ("E4", re.compile(r"\bcurl\b.*(?:-F\s|--form)", re.I)),
+    ("E4", re.compile(r"\bcurl\b.*(?:-T\s|--upload-file)", re.I)),
+    ("E4", re.compile(r"\bnpm\s+publish\b")),
+    ("E4", re.compile(r"\bkubectl\s+(?:apply|create|patch|scale)\b")),
+    ("E4", re.compile(r"\bterraform\s+(?:apply|destroy)\b")),
+    ("E4", re.compile(r"\bscp\b")),
+    ("E4", re.compile(r"\brsync\b.*[^-](?:--delete|--remove)")),
+    ("E4", re.compile(r"\bpsql\b.*-c\b")),
+    ("E4", re.compile(r"\bmysql\b.*-e\b")),
+    ("E4", re.compile(r"\bInvoke-WebRequest\b.*-Method\s+(?:Post|Put|Delete|Patch)", re.I)),
+    # E3 -- staging / filesystem writes
+    ("E3", re.compile(r"\bgit\s+push\b")),
+    ("E3", re.compile(r"\bdocker\s+push\b")),
+    ("E3", re.compile(r"\bchmod\b")),
+    ("E3", re.compile(r"\bchown\b")),
+    ("E3", re.compile(r"\brsync\b")),
+    ("E3", re.compile(r"\bpip\s+install\b")),
+    ("E3", re.compile(r"\bnpm\s+install\b")),
+    # PowerShell: read-only cmdlets via wrapper are E0 (must be before generic E3)
+    ("E0", re.compile(r"\bpowershell\b.*\b(?:Get-Content|Get-ChildItem|Get-Item|Get-Location|Get-Process|Get-Date|Select-String|Test-Path|Measure-Object|Format-Table|Sort-Object|Where-Object|Select-Object|ForEach-Object)\b", re.I)),
+    ("E3", re.compile(r"\bpowershell\b", re.I)),
+    ("E3", re.compile(r"\bcmd\s+/c\b", re.I)),
+    # E2 -- local writes
+    ("E2", re.compile(r"\bmv\b")),
+    ("E2", re.compile(r"\bcp\b")),
+    ("E2", re.compile(r"\btee\b")),
+    ("E2", re.compile(r"\bmkdir\b")),
+    ("E2", re.compile(r"\bmove\b", re.I)),  # Windows move
+    ("E2", re.compile(r"\bcopy\b", re.I)),  # Windows copy
+    # E0 -- read-only (explicit safe commands, Unix)
+    ("E0", re.compile(r"^\s*(?:ls|cat|head|tail|wc|file|stat|echo|pwd|whoami|date|which|find|grep|rg|fd|tree|du|df)\b")),
+    ("E0", re.compile(r"^\s*(?:git\s+(?:status|log|diff|show|branch|remote))\b")),
+    # python/node -c can execute arbitrary code including file writes — E2, not E0
+    ("E2", re.compile(r"^\s*(?:python|python3|node)\s+-c\b")),
+    ("E0", re.compile(r"^\s*curl\b(?!.*(?:-X|-d\b|--data|--request|-F\b|--form|-T\b|--upload))", re.I)),
+    # E0 -- read-only (Windows equivalents)
+    ("E0", re.compile(r"^\s*(?:dir|type|where|hostname|ver|systeminfo|whoami|set)\b", re.I)),
+    ("E0", re.compile(r"^\s*(?:Get-Content|Get-ChildItem|Get-Item|Get-Location|Get-Process|Get-Date)\b", re.I)),
+    ("E0", re.compile(r"^\s*(?:Select-String|Test-Path|Measure-Object)\b", re.I)),
+    ("E0", re.compile(r"^\s*(?:Invoke-WebRequest|wget|curl)\b(?!.*(?:-Method|-d\b|--data|-F\b|--form|--post))", re.I)),
+]
+
+# Shell meta-characters that separate independent commands
+_PIPE_SPLIT = re.compile(r"\s*(?:\|(?!\|)|&&|\|\||;|\$\(|`)\s*")
+
+
+def _classify_single(segment: str) -> str:
+    """Classify a single command segment against hard rules."""
+    for level, pattern in _HARD_RULES:
+        if pattern.search(segment):
+            return level
+    return "E2"
+
+
+def classify_command(command: str, llm_assessment: str = "") -> str:
+    """Classify a shell command's effect level. Hard rules only -- LLM self-report is ignored.
+
+    Splits on pipe, &&, ||, ;, $(), and backtick boundaries to prevent
+    a dangerous command from hiding behind a safe prefix like 'echo'.
+    Returns the highest (most dangerous) level found across all segments.
+    """
+    segments = _PIPE_SPLIT.split(command)
+    worst = "E0"
+    for seg in segments:
+        seg = seg.strip()
+        if not seg:
+            continue
+        level = _classify_single(seg)
+        if effect_to_int(level) > effect_to_int(worst):
+            worst = level
+    # Never go below E2 default for unrecognized commands
+    if effect_to_int(worst) < effect_to_int("E2") and not segments:
+        return "E2"
+    return worst
+
+
+def effect_to_int(level: str) -> int:
+    if level and len(level) == 2 and level[0] == "E" and level[1].isdigit():
+        return int(level[1])
+    return 0
+
+
+def check_allowed(command_level: str, max_level: str) -> bool:
+    return effect_to_int(command_level) <= effect_to_int(max_level)
+
+
+def get_max_effect(cli_max: str | None = None) -> str:
+    if cli_max and cli_max in EFFECT_LEVELS:
+        return cli_max
+    env = os.environ.get("PASCAL_MAX_EFFECT", "")
+    if env in EFFECT_LEVELS:
+        return env
+    return DEFAULT_MAX_EFFECT
+
+
+def escalation_message(command: str, level: str, max_level: str) -> str:
+    return (
+        f"Effect escalation: '{command[:80]}' is {level} ({EFFECT_LEVELS.get(level, '?')}), "
+        f"but max allowed is {max_level} ({EFFECT_LEVELS.get(max_level, '?')}). "
+        f"Use --max-effect {level} to allow."
+    )

pascal/eval/__init__.py

@@ -0,0 +1 @@
+"""Evaluation harness for Pascal."""

pascal/eval/smoke.py

@@ -0,0 +1,213 @@
+"""Smoke test harness -- 5 core scenarios that must pass for Pascal to be viable.
+
+Run: python -m pascal.eval.smoke
+
+1. Task lifecycle: receive → plan → execute → complete
+2. Interrupt: notification arrives mid-task → pause → handle → resume
+3. Escalation: agent encounters uncertainty → escalate → loop stops
+4. Self-learning: agent adds a rule → rule visible in next loop
+5. Governor: agent loops → detected → stopped
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Any, Callable
+
+from pascal.loop import run_loop
+from pascal.state import PascalStore
+from pascal.types import LLMResponse
+
+
+class _MockLLM:
+    def __init__(self, responses: list[str]):
+        self._responses = list(responses)
+        self._i = 0
+
+    async def chat(self, messages, tools=None):
+        if self._i >= len(self._responses):
+            return LLMResponse(text=json.dumps({"action": "wait", "reason": "out"}))
+        text = self._responses[self._i]
+        self._i += 1
+        return LLMResponse(text=text)
+
+
+def _j(**kwargs) -> str:
+    return json.dumps(kwargs)
+
+
+async def _run_scenario(
+    name: str,
+    store: PascalStore,
+    responses: list[str],
+    validate: "Callable",
+) -> tuple[bool, str]:
+    llm = _MockLLM(responses)
+    actions = await run_loop(store, llm, max_iterations=15)
+    try:
+        validate(store, actions)
+        return True, f"  PASS: {name}"
+    except AssertionError as e:
+        return False, f"  FAIL: {name} -- {e}"
+
+
+async def run_all(tmp_dir: str | None = None) -> dict[str, Any]:
+    import tempfile
+    base = Path(tmp_dir) if tmp_dir else Path(tempfile.mkdtemp())
+    results: list[tuple[bool, str]] = []
+
+    # 1. Task lifecycle
+    store = PascalStore(str(base / "s1.db"))
+    t1_id = store.add_task("Write hello.txt")
+
+    def v1(s, actions):
+        types = [a["action"] for a in actions]
+        assert "pick_task" in types, "should pick task"
+        assert "complete_task" in types or "wait" in types, "should complete or wait"
+
+    results.append(await _run_scenario("Task lifecycle", store, [
+        _j(action="pick_task", task_id=t1_id, reason="start"),
+        _j(action="execute", command="echo hello > hello.txt", reason="write"),
+        _j(action="complete_task", summary="Created hello.txt", reason="done"),
+        _j(action="wait", reason="done"),
+    ], v1))
+    store.close()
+
+    # 2. Interrupt handling
+    store = PascalStore(str(base / "s2.db"))
+    task_id = store.add_task("Long work")
+    store.activate_task(task_id)
+    notif_id = store.push_notification(source="slack", message="Server down!", priority="urgent")
+
+    def v2(s, actions):
+        types = [a["action"] for a in actions]
+        assert "pause_task" in types, "should pause"
+        assert "handle_notification" in types, "should handle notification"
+
+    results.append(await _run_scenario("Interrupt", store, [
+        _j(action="pause_task", pause_reason="urgent notification", reason="server"),
+        _j(action="handle_notification", notification_id=notif_id, response="checking", reason="urgent"),
+        _j(action="wait", reason="investigating"),
+    ], v2))
+    store.close()
+
+    # 3. Escalation
+    store = PascalStore(str(base / "s3.db"))
+    t3_id = store.add_task("Deploy to prod")
+
+    def v3(s, actions):
+        types = [a["action"] for a in actions]
+        assert "escalate" in types, "should escalate"
+
+    results.append(await _run_scenario("Escalation", store, [
+        _j(action="pick_task", task_id=t3_id, reason="start"),
+        _j(action="escalate", question="Prod deploy needs approval", reason="policy"),
+    ], v3))
+    store.close()
+
+    # 4. Self-learning
+    store = PascalStore(str(base / "s4.db"))
+    t4_id = store.add_task("Learn something")
+
+    def v4(s, actions):
+        rules = s.get_rules()
+        assert any("test" in r["rule"].lower() for r in rules), "should have added a rule"
+
+    results.append(await _run_scenario("Self-learning", store, [
+        _j(action="pick_task", task_id=t4_id, reason="start"),
+        _j(action="add_rule", rule="Always run tests before deploy", reason="learned"),
+        _j(action="complete_task", summary="Learned", reason="done"),
+        _j(action="wait", reason="done"),
+    ], v4))
+    store.close()
+
+    # 5. Governor (loop detection)
+    store = PascalStore(str(base / "s5.db"))
+    t5_id = store.add_task("Stuck task")
+
+    def v5(s, actions):
+        assert len(actions) < 15, f"should stop early, got {len(actions)} actions"
+
+    results.append(await _run_scenario("Governor", store, [
+        _j(action="pick_task", task_id=t5_id, reason="start"),
+        _j(action="execute", command="false", reason="try"),
+        _j(action="execute", command="false", reason="retry"),
+        _j(action="execute", command="false", reason="retry again"),
+        _j(action="execute", command="false", reason="still trying"),
+        _j(action="execute", command="false", reason="one more"),
+        _j(action="wait", reason="governor should have warned"),
+    ], v5))
+    store.close()
+
+    # 6. Plan execution (multi-step in one LLM call)
+    store = PascalStore(str(base / "s6.db"))
+    t6_id = store.add_task("Multi-step work")
+
+    def v6(s, actions):
+        plan_actions = [a for a in actions if a["action"] == "plan"]
+        assert plan_actions, "should execute a plan"
+        plan_result = plan_actions[0]["result"]
+        assert plan_result.get("plan_completed"), "plan should complete"
+        assert len(plan_result.get("steps", [])) >= 2, "plan should have multiple steps"
+
+    results.append(await _run_scenario("Plan execution", store, [
+        _j(action="pick_task", task_id=t6_id, reason="start"),
+        _j(action="plan", reason="do two things", steps=[
+            {"action": "execute", "command": "echo step1"},
+            {"action": "execute", "command": "echo step2"},
+        ]),
+        _j(action="complete_task", summary="Done via plan", reason="done"),
+        _j(action="wait", reason="done"),
+    ], v6))
+    store.close()
+
+    # 7. Memory search (FTS5 relevance)
+    store = PascalStore(str(base / "s7.db"))
+    store.add_memory(kind="fact", content="The deploy server runs on port 8080")
+    store.add_memory(kind="lesson", content="Always backup before migration")
+    store.add_memory(kind="fact", content="Database password is rotated monthly")
+    t7_id = store.add_task("Check deploy config")
+
+    def v7(s, actions):
+        # Verify memory search finds relevant results
+        results = s.search_memories("deploy server", limit=3)
+        assert any("8080" in m["content"] for m in results), "should find deploy memory"
+
+    results.append(await _run_scenario("Memory search", store, [
+        _j(action="pick_task", task_id=t7_id, reason="start"),
+        _j(action="wait", reason="done"),
+    ], v7))
+    store.close()
+
+    # 8. Conversation thread + dependency gating
+    store = PascalStore(str(base / "s8.db"))
+    t8a = store.add_task("Build the app")
+    t8b = store.add_task("Deploy the app", depends_on=[t8a])
+
+    def v8(s, actions):
+        # t8b should NOT be picked (depends on t8a which isn't done)
+        from pascal.desk import Desk
+        desk = Desk(s)
+        rendered = desk.render()
+        # t8b should not appear in actionable queue (dependency not met)
+        assert t8b not in rendered or "Deploy" not in rendered.split("Task Queue")[1] if "Task Queue" in rendered else True
+
+    results.append(await _run_scenario("Dependency gating", store, [
+        _j(action="pick_task", task_id=t8a, reason="build first"),
+        _j(action="wait", reason="building"),
+    ], v8))
+    store.close()
+
+    passed = sum(1 for ok, _ in results if ok)
+    total = len(results)
+    print(f"\nPascal Smoke Test: {passed}/{total} passed\n")
+    for _, msg in results:
+        print(msg)
+
+    return {"passed": passed, "total": total, "results": results}
+
+
+if __name__ == "__main__":
+    asyncio.run(run_all())

pascal/llm/__init__.py

@@ -0,0 +1 @@
+"""LLM abstraction layer."""

pascal/llm/anthropic.py

@@ -0,0 +1,225 @@
+"""pascal/llm/anthropic.py -- Anthropic 프로바이더."""
+
+from __future__ import annotations
+
+import logging
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Literal, TypeAlias
+
+if TYPE_CHECKING:
+    from anthropic import AsyncAnthropic
+    from anthropic.types import (
+        Base64ImageSourceParam,
+        ImageBlockParam,
+        MessageParam,
+        TextBlockParam,
+        ToolParam,
+        ToolResultBlockParam,
+        ToolUseBlockParam,
+    )
+else:
+    AsyncAnthropic = Any
+    Base64ImageSourceParam = dict[str, object]
+    ImageBlockParam = dict[str, object]
+    MessageParam = dict[str, object]
+    TextBlockParam = dict[str, object]
+    ToolParam = dict[str, object]
+    ToolResultBlockParam = dict[str, object]
+    ToolUseBlockParam = dict[str, object]
+
+try:
+    import anthropic as anthropic_module
+except ImportError:  # pragma: no cover - optional dependency
+    anthropic: ModuleType | None = None
+else:
+    anthropic = anthropic_module
+
+from pascal.types import ContentBlock, LLMResponse, Message, Role, ToolCall
+
+logger = logging.getLogger(__name__)
+
+AnthropicImageMediaType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
+AnthropicContentBlock: TypeAlias = TextBlockParam | ImageBlockParam
+AnthropicAssistantBlock: TypeAlias = AnthropicContentBlock | ToolUseBlockParam
+
+
+class AnthropicProvider:
+    """Anthropic Claude API를 사용하는 LLM 프로바이더."""
+
+    _client: AsyncAnthropic
+
+    def __init__(self, model: str = "claude-sonnet-4-20250514", base_url: str = "") -> None:
+        if anthropic is None:
+            raise ImportError(
+                "Anthropic provider requires optional dependency: pip install pascal[anthropic]"
+            )
+        from anthropic import AsyncAnthropic
+
+        if base_url:
+            self._client = AsyncAnthropic(base_url=base_url)
+        else:
+            self._client = AsyncAnthropic()
+        self._model = model
+
+    async def chat(
+        self,
+        messages: list[Message],
+        tools: list[dict] | None = None,
+    ) -> LLMResponse:
+        system_parts: list[str] = []
+        api_messages: list[MessageParam] = []
+
+        for m in messages:
+            if m.role == Role.SYSTEM:
+                system_parts.append(m.content)
+            elif m.role == Role.ASSISTANT:
+                content = self._build_assistant_content(m)
+                assistant_message: MessageParam = {"role": "assistant", "content": content}
+                api_messages.append(assistant_message)
+            elif m.role == Role.TOOL:
+                tool_result: ToolResultBlockParam = {
+                    "type": "tool_result",
+                    "tool_use_id": m.tool_call_id,
+                    "content": m.content,
+                }
+                tool_result_message: MessageParam = {"role": "user", "content": [tool_result]}
+                api_messages.append(tool_result_message)
+            else:
+                api_messages.append(self._convert_user_message(m))
+
+        system = "\n\n".join(system_parts) if system_parts else None
+        converted_tools = self._convert_tools(tools) if tools else None
+
+        if system is not None and converted_tools is not None:
+            response = await self._client.messages.create(
+                model=self._model,
+                max_tokens=4096,
+                messages=api_messages,
+                system=system,
+                tools=converted_tools,
+            )
+        elif system is not None:
+            response = await self._client.messages.create(
+                model=self._model,
+                max_tokens=4096,
+                messages=api_messages,
+                system=system,
+            )
+        elif converted_tools is not None:
+            response = await self._client.messages.create(
+                model=self._model,
+                max_tokens=4096,
+                messages=api_messages,
+                tools=converted_tools,
+            )
+        else:
+            response = await self._client.messages.create(
+                model=self._model,
+                max_tokens=4096,
+                messages=api_messages,
+            )
+        return self._parse_response(response)
+
+    def _build_assistant_content(self, msg: Message) -> list[AnthropicAssistantBlock] | str:
+        content: list[AnthropicAssistantBlock] = list(self._build_content_blocks(msg))
+        tool_calls = getattr(msg, "tool_calls", None) or []
+        if not tool_calls:
+            return content or msg.content
+
+        for tc in tool_calls:
+            content.append(
+                {
+                    "type": "tool_use",
+                    "id": tc.id,
+                    "name": tc.name,
+                    "input": tc.params,
+                }
+            )
+        return content
+
+    def _convert_user_message(self, msg: Message) -> MessageParam:
+        content = self._build_content_blocks(msg)
+        return {"role": "user", "content": content or msg.content}
+
+    def _build_content_blocks(self, msg: Message) -> list[AnthropicContentBlock]:
+        content: list[AnthropicContentBlock] = []
+        if msg.content:
+            content.append({"type": "text", "text": msg.content})
+        for attachment in msg.attachments:
+            block = self._convert_attachment(attachment)
+            if block is not None:
+                content.append(block)
+        return content
+
+    def _convert_attachment(self, attachment: ContentBlock) -> AnthropicContentBlock | None:
+        if attachment.type == "image":
+            media_type = self._normalize_image_media_type(attachment.mime_type)
+            if media_type is None:
+                logger.warning("Unsupported Anthropic image media type: %s", attachment.mime_type)
+                return None
+            source: Base64ImageSourceParam = {
+                "type": "base64",
+                "media_type": media_type,
+                "data": attachment.data,
+            }
+            image_block: ImageBlockParam = {
+                "type": "image",
+                "source": source,
+            }
+            return image_block
+        if attachment.type == "text":
+            text_block: TextBlockParam = {"type": "text", "text": attachment.data}
+            return text_block
+
+        logger.warning("Unsupported content block for Anthropic provider: %s", attachment.type)
+        return None
+
+    @staticmethod
+    def _normalize_image_media_type(mime_type: str) -> AnthropicImageMediaType | None:
+        if mime_type == "image/jpeg":
+            return "image/jpeg"
+        if mime_type == "image/png":
+            return "image/png"
+        if mime_type == "image/gif":
+            return "image/gif"
+        if mime_type == "image/webp":
+            return "image/webp"
+        return None
+
+    @staticmethod
+    def _convert_tools(tools: list[dict]) -> list[ToolParam]:
+        default_schema: dict[str, object] = {"type": "object", "properties": {}}
+        result: list[ToolParam] = []
+        for t in tools:
+            func = t.get("function", t)
+            name: str = func["name"]
+            description: str = func.get("description", "")
+            input_schema: dict[str, object] = func.get("parameters", default_schema)
+            result.append(
+                {
+                    "name": name,
+                    "description": description,
+                    "input_schema": input_schema,
+                }
+            )
+        return result
+
+    @staticmethod
+    def _parse_response(response) -> LLMResponse:
+        text_parts = []
+        tool_calls = []
+
+        for block in response.content:
+            if block.type == "text":
+                text_parts.append(block.text)
+            elif block.type == "tool_use":
+                tool_calls.append(
+                    ToolCall(
+                        id=block.id,
+                        name=block.name,
+                        params=block.input,
+                    )
+                )
+
+        text = "\n".join(text_parts) if text_parts else None
+        return LLMResponse(text=text, tool_calls=tool_calls)