The SHIPIT Workspace

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))

import json
import tempfile
from pathlib import Path

from shipit_agent import Agent
from shipit_agent.llms import ShipitLLM


def fresh_project() -> Path:
    """A brand-new temp dir to act as a project root (self-contained per cell)."""
    root = Path(tempfile.mkdtemp(prefix="shipit_ws_"))
    return root


def show(label, text, limit=900):
    print(f"=== {label} ===")
    print(text[:limit] + ("…" if len(text) > limit else ""))

root = fresh_project()

# A repo-root SHIPIT.md: the primary project instructions file.
(root / "SHIPIT.md").write_text(
    "# Project rules\n"
    "- Always write tests for new behavior.\n"
    "- Prefer small, focused functions.\n",
    encoding="utf-8",
)

# Build an agent rooted at the repo — instructions load automatically.
agent = Agent(llm=ShipitLLM(), project_root=root)

print("SHIPIT.md content is in the system prompt:",
      "Always write tests" in agent.prompt)
print()
show("agent.prompt (tail)", agent.prompt[-500:])

root = fresh_project()
(root / ".shipit").mkdir(parents=True, exist_ok=True)

# Imported file (pulled in via @import below).
(root / "STYLE.md").write_text(
    "# Style guide\n- Line length <= 88.\n", encoding="utf-8"
)

# Primary file imports STYLE.md via a line that is exactly `@STYLE.md`.
(root / "SHIPIT.md").write_text(
    "# Project rules\n- Always write tests.\n\[email]\n",
    encoding="utf-8",
)

# The conventional AGENTS.md is ALSO picked up (separate block).
(root / "AGENTS.md").write_text(
    "# Agent notes\n- This repo deploys on merge to main.\n",
    encoding="utf-8",
)

# And a nested .shipit/SHIPIT.md (separate block again).
(root / ".shipit" / "SHIPIT.md").write_text(
    "# Workspace rules\n- Use the staging DB locally.\n",
    encoding="utf-8",
)

from shipit_agent.workspace import load_project_memory

# include_user=False keeps this demo deterministic (ignores ~/.shipit).
memory = load_project_memory(root, include_user=False)
print(memory)

root = fresh_project()
(root / "SHIPIT.md").write_text("# Secret rules\n- Do X.\n", encoding="utf-8")

on = Agent(llm=ShipitLLM(), project_root=root)
off = Agent(llm=ShipitLLM(), project_root=root, auto_project_memory=False)

print("default  (auto_project_memory=True): rules loaded? ",
      "Secret rules" in on.prompt)
print("opted-out (auto_project_memory=False): rules loaded?",
      "Secret rules" in off.prompt)

root = fresh_project()
commands = root / ".shipit" / "commands"
commands.mkdir(parents=True, exist_ok=True)

# A command using $1 (first arg). No f-string: $1/$ARGUMENTS are literal.
(commands / "greet.md").write_text(
    "Greet $1 warmly and ask what they are working on today.",
    encoding="utf-8",
)

# A command with frontmatter + $ARGUMENTS (the whole arg string).
(commands / "review.md").write_text(
    "---\n"
    "description: Review a file for bugs\n"
    "---\n"
    "Carefully review the file $ARGUMENTS for bugs and style issues. "
    "List concrete fixes.",
    encoding="utf-8",
)

agent = Agent(llm=ShipitLLM(), project_root=root)

# /greet Ada -> the expanded prompt reaches the (echo) model.
result = agent.run("/greet Ada")
# The echo output is `system prompt + expanded user turn`; print the tail so the
# substituted command body ($1 -> Ada) is visible (the head is the system prompt).
print("expanded user turn (last line the model saw):")
print(" …", result.output.splitlines()[-1])
print()
show("full echo (system + expanded /greet)", result.output)

# Inspect the command machinery directly.
from shipit_agent.workspace import discover_commands, expand_command

print("discovered commands:", list(discover_commands(root)))
print()
print("expand /review:")
print(expand_command(root, "/review src/app.py"))
print()
# An unknown command returns None, so a normal prompt passes through unchanged.
print("expand /unknown ->", expand_command(root, "/unknown blah"))

root = fresh_project()
(root / ".shipit").mkdir(parents=True, exist_ok=True)
(root / ".shipit" / "settings.json").write_text(
    json.dumps(
        {
            "model": "anthropic/claude-3-5-sonnet",
            "permissions": {
                "mode": "default",
                "deny": ["bash", "*_delete"],
                "ask": ["sql"],
                "allow": ["read*"],
            },
            "env": {"SHIPIT_LLM_PROVIDER": "anthropic"},
        },
        indent=2,
    ),
    encoding="utf-8",
)

from shipit_agent.workspace import load_settings

settings = load_settings(root, include_user=False)
print("model:", settings.model)
print("deny :", settings.deny)
print("ask  :", settings.ask)
print("allow:", settings.allow)
print("env  :", settings.env)

engine = settings.to_permission_engine()
print("permission engine:", type(engine).__name__)

from shipit_agent.llms.base import LLMResponse
from shipit_agent.models import ToolCall


class ScriptedLLM:
    """Deterministic offline LLM: replays a fixed list of responses."""

    def __init__(self, responses):
        self._responses = list(responses)
        self._i = 0

    def complete(self, *, messages, tools=None, system_prompt=None,
                 metadata=None, **kwargs):
        if self._i < len(self._responses):
            resp = self._responses[self._i]
            self._i += 1
            return resp
        return LLMResponse(content="done")

from shipit_agent import Agent, FunctionTool


def bash(command: str = "") -> str:
    return f"(pretend) ran: {command}"


# The model's first move is to call the DENIED `bash` tool.
scripted = ScriptedLLM([
    LLMResponse(tool_calls=[ToolCall(name="bash",
                                     arguments={"command": "rm -rf /"})]),
    LLMResponse(content="Understood — I won't run that."),
])

agent = Agent.for_project(
    llm=scripted,
    project_root=str(root),  # same root: settings.json deny=['bash', ...]
    tools=[FunctionTool.from_callable(bash, name="bash",
                                      description="Run a shell command.")],
)
result = agent.run("Please clean up the workspace.")

denied = [e for e in result.events if e.type == "tool_denied"]
print("final output:", result.output)
print("tool_denied events:",
      [(e.message, e.payload.get("reason")) for e in denied])