The Super Agent: every sector, clean logs, real deliverables

from pathlib import Path
import sys

ROOT = (
    Path.cwd().resolve().parent
    if Path.cwd().name == "notebooks"
    else Path.cwd().resolve()
)
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from shipit_agent import (
    Agent,
    AgentScheduler,
    format_activity,
    format_event_line,
    list_mcp_catalog,
)
from shipit_agent.llms.base import LLMResponse, ToolCall

print("imports OK")

class ScriptedLLM:
    """Offline stand-in: first turn calls build_document, then answers."""
    def __init__(self):
        self.turn = 0
    def complete(self, *, messages, tools=None, **_):
        self.turn += 1
        if self.turn == 1:
            return LLMResponse(tool_calls=[ToolCall(
                name="build_document",
                arguments={
                    "kind": "xlsx",
                    "title": "Q2 Close",
                    "sheets": [{
                        "name": "P&L",
                        "headers": ["Item", "Amount"],
                        "rows": [
                            ["Revenue", 124_000],
                            ["Costs", -78_500],
                            ["Net", "=B2+B3"],   # live formula
                        ],
                    }],
                },
            )])
        return LLMResponse(content="Q2 close workbook is ready — net income formula included.")

for role in ("finance-analyst", "marketing-writer", "researcher",
             "figma-designer", "sales-rep", "generalist-developer"):
    a = Agent.for_role(role, llm=ScriptedLLM())
    print(f"{role:<24} {len(a.tools):>2} tools · {a.metadata['category']}")

# Unknown ids fail helpfully with did-you-mean suggestions:
try:
    Agent.for_role("finance", llm=ScriptedLLM())
except ValueError as e:
    print(e)

for entry in list_mcp_catalog():
    env = f"   (needs {', '.join(entry.required_env)})" if entry.required_env else ""
    print(f"{entry.name:<14} {entry.description}{env}")

# Fail-fast: misconfiguration is one clear message, not a subprocess stack trace.
from shipit_agent import connect_mcp
import os

os.environ.pop("SLACK_BOT_TOKEN", None)
try:
    connect_mcp("slack")
except ValueError as e:
    print(e)

# When configured, it's one line into the agent:
#   agent = Agent.with_builtins(llm=llm, mcps=[connect_mcp("github")])

agent = Agent.for_role("finance-analyst", llm=ScriptedLLM())
result = agent.run("Close Q2 and hand me the workbook.")

print(format_activity(result))
print()
print("Final answer:", result.output)

# Verify the workbook is real — reopen it and check the live formula.
import openpyxl

done = [e for e in result.events if e.type == "tool_completed"][0]
path = [t.metadata["path"] for t in result.tool_results if t.metadata.get("path")][0]
wb = openpyxl.load_workbook(path)
ws = wb["P&L"]
print("header bold:  ", ws["A1"].font.bold)
print("frozen panes: ", ws.freeze_panes)
print("live formula: ", ws["B4"].value)
print("duration_ms:  ", done.payload["duration_ms"])

# Live rendering for streams — format_event_line returns a line per user-facing event.
agent2 = Agent.for_role("finance-analyst", llm=ScriptedLLM())
for event in agent2.stream("Close Q2 again."):
    line = format_event_line(event)
    if line:
        print(line)

class FakeClock:
    def __init__(self, start=1_000_000.0): self.now = start
    def __call__(self): return self.now
    def advance(self, s): self.now += s

class TinyLLM:
    def complete(self, *, messages, **_):
        return LLMResponse(content="[done]")

clock = FakeClock()
agent3 = Agent(llm=TinyLLM(), auto_use_skills=False)
sched = AgentScheduler(agent3, clock=clock, sleep=lambda s: None)

log = []
sched.add("Summarize new error logs.", every=3600,
          name="hourly-digest", on_result=lambda r: log.append("hourly"))
sched.add("Draft today's product post.", at="09:00",
          name="daily-post", on_result=lambda r: log.append("daily"))

for hour in range(26):          # simulate 26 hours — instant
    clock.advance(3600)
    sched.run_pending()

print(f"hourly-digest fired {log.count('hourly')}x, daily-post fired {log.count('daily')}x")
print("In production: sched.run_forever()  # blocks, firing jobs as due")