pascal-agent 0.3.3__tar.gz → 0.3.4__tar.gz

{pascal_agent-0.3.3 → pascal_agent-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pascal-agent
-Version: 0.3.3
+Version: 0.3.4
 Summary: Pascal — autonomous AI employee runtime with 4-layer safety
 Project-URL: Homepage, https://gitlab.com/laum0621/pascal
 Project-URL: Repository, https://gitlab.com/laum0621/pascal

{pascal_agent-0.3.3 → pascal_agent-0.3.4}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/pascal"]
 
 [project]
 name = "pascal-agent"
-version = "0.3.3"
+version = "0.3.4"
 description = "Pascal — autonomous AI employee runtime with 4-layer safety"
 readme = "README.md"
 license = {text = "MIT"}

{pascal_agent-0.3.3 → pascal_agent-0.3.4}/src/pascal/__init__.py

@@ -1,3 +1,3 @@
 """Pascal -- autonomous AI employee built on a working-document loop."""
 
-__version__ = "0.3.3"
+__version__ = "0.3.4"

{pascal_agent-0.3.3 → pascal_agent-0.3.4}/src/pascal/__main__.py

@@ -11,6 +11,15 @@ import sys
 from pathlib import Path
 from textwrap import dedent
 
+# Force UTF-8 output on Windows (fixes Korean/CJK text garbling)
+if sys.platform == "win32":
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            try:
+                stream.reconfigure(encoding="utf-8", errors="replace")
+            except Exception:
+                pass
+
 from pascal.config import load_config
 from pascal.receipts import Ledger
 from pascal.loop import run_loop
@@ -60,15 +69,46 @@ _EFFECTS = ("E0", "E1", "E2", "E3", "E4", "E5")
 
 
 _SPINNER_FRAMES = ["|", "/", "-", "\\"]
-_spinner_idx = 0
 _active_model = ""  # set before loop starts
 
+# Background spinner state
+_spinner_running = False
+_spinner_thread = None
+_spinner_msg = "thinking..."
+
+
+def _start_spinner(msg: str = "thinking...") -> None:
+    """Start background spinner thread."""
+    import threading
+    global _spinner_running, _spinner_thread, _spinner_msg
+    _spinner_msg = msg
+    if _spinner_running:
+        return
+    _spinner_running = True
 
-def _spin() -> str:
-    global _spinner_idx
-    frame = _SPINNER_FRAMES[_spinner_idx % len(_SPINNER_FRAMES)]
-    _spinner_idx += 1
-    return frame
+    def _spin_loop():
+        import time
+        idx = 0
+        while _spinner_running:
+            frame = _SPINNER_FRAMES[idx % len(_SPINNER_FRAMES)]
+            model_tag = f" ({_active_model})" if _active_model else ""
+            print(f"\r  {frame} {_spinner_msg}{model_tag}   ", end="", flush=True)
+            idx += 1
+            time.sleep(0.15)
+
+    _spinner_thread = threading.Thread(target=_spin_loop, daemon=True)
+    _spinner_thread.start()
+
+
+def _stop_spinner(clear: bool = True) -> None:
+    """Stop background spinner and clear the line."""
+    global _spinner_running, _spinner_thread
+    _spinner_running = False
+    if _spinner_thread:
+        _spinner_thread.join(timeout=1)
+        _spinner_thread = None
+    if clear:
+        print(f"\r{' ' * 60}\r", end="", flush=True)
 
 
 # Actions hidden from user (internal bookkeeping)
@@ -86,34 +126,32 @@ def _print_action(action: dict) -> None:
     error = result.get("error", "") if isinstance(result, dict) else ""
     output = result.get("output", "") if isinstance(result, dict) else ""
 
-    # Silent actions: just spin with model name
+    # Silent actions: start/keep spinner
     if a in _SILENT_ACTIONS:
-        model_tag = f" ({_active_model})" if _active_model else ""
-        print(f"\r  {_spin()} thinking...{model_tag}   ", end="", flush=True)
+        _start_spinner("thinking...")
         return
 
-    # Clear spinner line
-    print(f"\r{' ' * 40}\r", end="")
+    # Visible action: stop spinner, print result
+    _stop_spinner()
 
     if a == "execute":
         tool = result.get("tool", "") if isinstance(result, dict) else ""
-        # Show what was executed
         label = tool or reason[:60] or "running"
         if error:
             print(f"  x {label} -- {error[:80]}")
         elif output:
             preview = output.strip().split("\n")[0][:80]
-            print(f"  {_spin()} {label} -> {preview}")
+            print(f"  > {label} -> {preview}")
         else:
-            print(f"  {_spin()} {label}")
+            print(f"  > {label}")
 
     elif a == "delegate":
-        tool = action.get("result", {}).get("tool", "agent") if isinstance(action.get("result"), dict) else "agent"
+        tool = result.get("tool", "agent") if isinstance(result, dict) else "agent"
         print(f"  -> delegating to {tool}...")
 
     elif a == "plan":
         count = result.get("executed", 0) if isinstance(result, dict) else 0
-        print(f"  {_spin()} planning ({count} steps)")
+        print(f"  > planning ({count} steps)")
 
     elif a == "complete_task":
         summary = result.get("summary", reason) if isinstance(result, dict) else reason
@@ -129,8 +167,20 @@ def _print_action(action: dict) -> None:
     elif a == "wait":
         pass  # silent
 
+    elif a == "text_response":
+        # LLM replied with plain text (no tool calls) — show directly
+        text = result.get("text", reason) if isinstance(result, dict) else reason
+        if text:
+            print(f"\n  {text}\n")
+
     elif a == "handle_notification":
-        print("  ! notification handled")
+        reply = result.get("reply_text", "") if isinstance(result, dict) else ""
+        if reply and reply.upper() != "NO_REPLY":
+            print(f"\n  {reply}")
+        else:
+            response = result.get("response", "") if isinstance(result, dict) else ""
+            if response:
+                print(f"\n  {response[:120]}")
 
     else:
         # Fallback for unknown actions
@@ -855,12 +905,20 @@ def _print_banner() -> None:
     print()
 
 
-async def _run_one_task(task: str, config) -> None:
-    """Run a single task through the loop. Shared by REPL and one-shot mode."""
+async def _run_one_task(task: str, config, *, force_task: bool = False) -> None:
+    """Run a single task through the loop.
+
+    force_task=True: always create as task (one-shot CLI mode).
+    force_task=False: push as notification, let LLM decide (REPL mode).
+    """
     global _active_model
     _active_model = config.model
     store = PascalStore(config.db_path)
-    store.add_task(task, source="cli")
+    if force_task:
+        store.add_task(task, source="cli")
+    else:
+        # Let the LLM decide: casual chat → reply, real work → create_task
+        store.push_notification(source="user", message=task, priority="normal")
 
     from pascal.config import create_llm
     llm = create_llm(config)
@@ -877,6 +935,7 @@ async def _run_one_task(task: str, config) -> None:
         except Exception:
             pass  # MCP is optional
 
+    _start_spinner("thinking...")
     try:
         await run_loop(
             store, llm,
@@ -889,6 +948,7 @@ async def _run_one_task(task: str, config) -> None:
             on_action=_print_action,
         )
     finally:
+        _stop_spinner()
         try:
             await mcp_manager.disconnect_all()
         except Exception:
@@ -898,12 +958,6 @@ async def _run_one_task(task: str, config) -> None:
 
 def _interactive() -> None:
     """Interactive REPL mode -- type tasks, see Pascal work, repeat."""
-    # Ensure UTF-8 output on Windows
-    if hasattr(sys.stdout, "reconfigure"):
-        try:
-            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
-        except Exception:
-            pass
     if not _ensure_ready():
         return
 

{pascal_agent-0.3.3 → pascal_agent-0.3.4}/src/pascal/loop.py

@@ -556,10 +556,20 @@ class LoopRunner:
             tool_calls = list(response.tool_calls or [])
             self.state.consecutive_errors = 0
 
-            # No tool_calls = text response → done
+            # No tool_calls = text response → show to user and done
             if not tool_calls:
                 if response.text:
                     messages.append(Message(role=Role.ASSISTANT, content=response.text))
+                    # Surface text response via on_action so REPL can display it
+                    text_record = {
+                        "iteration": iteration, "action": "text_response",
+                        "reason": response.text,
+                        "result": {"text": response.text},
+                    }
+                    self.state.actions_taken.append(text_record)
+                    if self.on_action:
+                        self.on_action(text_record)
+                    _broadcast_action(text_record)
                 return ToolUseResult(stop_reason="text_response")
 
             # Assistant message — tool_calls directly, no JSON serialization

{pascal_agent-0.3.3 → pascal_agent-0.3.4}/tests/test_loop.py

@@ -187,8 +187,8 @@ class TestSafety:
                 return LLMResponse(text="this is not json at all")
 
         actions = await run_loop(store, BadLLM(), max_iterations=10)
-        # Should stop after retries, not run forever
-        assert len(actions) == 0
+        # Text-only responses are now recorded as text_response actions
+        assert all(a["action"] == "text_response" for a in actions)
         store.close()
 
 
@@ -397,42 +397,42 @@ class TestInnerLoop:
         store.close()
 
 
-class TestDeltaDesk:
-    """Tests for differential desk rendering."""
-
-    def test_render_static_only_queries_identity_and_rules(self, tmp_path, monkeypatch):
-        store = PascalStore(str(tmp_path / "test.db"))
-        store.set_context("identity", {"name": "Pascal"})
-        store.add_rule("No force push", tier="policy", mutable=False)
-
-        desk = Desk(store)
-
-        def _fail(name: str):
-            def _inner(*args, **kwargs):
-                raise AssertionError(f"{name} should not be queried by render_static()")
-            return _inner
-
-        for method_name in (
-            "get_active_task",
-            "get_pending_tasks",
-            "get_pending_notifications",
-            "get_recent_history",
-            "get_todos",
-            "search_memories",
-            "get_memories",
-        ):
-            monkeypatch.setattr(store, method_name, _fail(method_name))
-
-        rendered = desk.render_static()
-
-        assert "Pascal" in rendered
-        assert "No force push" in rendered
-        store.close()
-
-    def test_render_delta_is_shorter_than_full(self, tmp_path):
-        """Delta render should produce significantly fewer chars than full render."""
-        store = PascalStore(str(tmp_path / "test.db"))
-        store.add_task("Review PR 42", priority="urgent")
+class TestDeltaDesk:
+    """Tests for differential desk rendering."""
+
+    def test_render_static_only_queries_identity_and_rules(self, tmp_path, monkeypatch):
+        store = PascalStore(str(tmp_path / "test.db"))
+        store.set_context("identity", {"name": "Pascal"})
+        store.add_rule("No force push", tier="policy", mutable=False)
+
+        desk = Desk(store)
+
+        def _fail(name: str):
+            def _inner(*args, **kwargs):
+                raise AssertionError(f"{name} should not be queried by render_static()")
+            return _inner
+
+        for method_name in (
+            "get_active_task",
+            "get_pending_tasks",
+            "get_pending_notifications",
+            "get_recent_history",
+            "get_todos",
+            "search_memories",
+            "get_memories",
+        ):
+            monkeypatch.setattr(store, method_name, _fail(method_name))
+
+        rendered = desk.render_static()
+
+        assert "Pascal" in rendered
+        assert "No force push" in rendered
+        store.close()
+
+    def test_render_delta_is_shorter_than_full(self, tmp_path):
+        """Delta render should produce significantly fewer chars than full render."""
+        store = PascalStore(str(tmp_path / "test.db"))
+        store.add_task("Review PR 42", priority="urgent")
         store.set_context("mission", "Ship fast")
         store.push_notification(source="slack", message="New review")
         store.add_rule("Always run tests", tier="policy", mutable=False)
@@ -481,56 +481,56 @@ class TestDeltaDesk:
         assert "File created" in delta
         store.close()
 
-    def test_render_delta_shows_urgent_notifications(self, tmp_path):
-        """Urgent notifications must appear in delta (safety critical)."""
-        store = PascalStore(str(tmp_path / "test.db"))
-        store.push_notification(source="telegram", message="Server is down!", priority="urgent")
+    def test_render_delta_shows_urgent_notifications(self, tmp_path):
+        """Urgent notifications must appear in delta (safety critical)."""
+        store = PascalStore(str(tmp_path / "test.db"))
+        store.push_notification(source="telegram", message="Server is down!", priority="urgent")
 
         desk = Desk(store)
         delta = desk.render_delta()
 
-        assert "URGENT" in delta
-        assert "Server is down" in delta
-        store.close()
-
-    def test_render_delta_queries_only_needed_state(self, tmp_path, monkeypatch):
-        store = PascalStore(str(tmp_path / "test.db"))
-        task_id = store.add_task("Deploy v2")
-        store.activate_task(task_id)
-        store.add_todo(task_id=task_id, title="Run tests")
-        store.set_context("mission", "Ship quality code")
-        store.set_context("identity", {"name": "Pascal"})
-        store.push_notification(source="telegram", message="Server is down!", priority="urgent")
-        store.add_rule("No force push", tier="policy", mutable=False)
-        store.add_memory(kind="lesson", content="Deploys need smoke tests")
-
-        desk = Desk(store)
-        active_calls = 0
-        original_get_active_task = store.get_active_task
-
-        def _counted_get_active_task(*args, **kwargs):
-            nonlocal active_calls
-            active_calls += 1
-            return original_get_active_task(*args, **kwargs)
-
-        def _fail(name: str):
-            def _inner(*args, **kwargs):
-                raise AssertionError(f"{name} should not be queried by render_delta()")
-            return _inner
-
-        monkeypatch.setattr(store, "get_active_task", _counted_get_active_task)
-        for method_name in ("get_pending_tasks", "get_recent_history"):
-            monkeypatch.setattr(store, method_name, _fail(method_name))
-
-        delta = desk.render_delta()
-
-        assert "Deploy v2" in delta
-        assert active_calls == 1
-        store.close()
-
-    async def test_subsequent_outer_iterations_use_desk_update(self, tmp_path):
-        """After the first outer iteration, subsequent iterations use a
-        [desk update] delta prompt instead of the full desk render.
+        assert "URGENT" in delta
+        assert "Server is down" in delta
+        store.close()
+
+    def test_render_delta_queries_only_needed_state(self, tmp_path, monkeypatch):
+        store = PascalStore(str(tmp_path / "test.db"))
+        task_id = store.add_task("Deploy v2")
+        store.activate_task(task_id)
+        store.add_todo(task_id=task_id, title="Run tests")
+        store.set_context("mission", "Ship quality code")
+        store.set_context("identity", {"name": "Pascal"})
+        store.push_notification(source="telegram", message="Server is down!", priority="urgent")
+        store.add_rule("No force push", tier="policy", mutable=False)
+        store.add_memory(kind="lesson", content="Deploys need smoke tests")
+
+        desk = Desk(store)
+        active_calls = 0
+        original_get_active_task = store.get_active_task
+
+        def _counted_get_active_task(*args, **kwargs):
+            nonlocal active_calls
+            active_calls += 1
+            return original_get_active_task(*args, **kwargs)
+
+        def _fail(name: str):
+            def _inner(*args, **kwargs):
+                raise AssertionError(f"{name} should not be queried by render_delta()")
+            return _inner
+
+        monkeypatch.setattr(store, "get_active_task", _counted_get_active_task)
+        for method_name in ("get_pending_tasks", "get_recent_history"):
+            monkeypatch.setattr(store, method_name, _fail(method_name))
+
+        delta = desk.render_delta()
+
+        assert "Deploy v2" in delta
+        assert active_calls == 1
+        store.close()
+
+    async def test_subsequent_outer_iterations_use_desk_update(self, tmp_path):
+        """After the first outer iteration, subsequent iterations use a
+        [desk update] delta prompt instead of the full desk render.
 
         With max_inner_turns=2 the tool-use loop caps at 2 rounds, forcing
         a second outer iteration where the delta prompt is appended."""