attache 0.0.1__py3-none-any.whl

attache/__init__.py

@@ -0,0 +1,3 @@
+"""Attaché: a personal assistant you install with one command."""
+
+__version__ = "0.0.1"  # the single source; pyproject.toml reads it, release.yml checks tags

attache/__main__.py

@@ -0,0 +1,3 @@
+from attache.cli import main
+
+raise SystemExit(main())

attache/agent.py

@@ -0,0 +1,85 @@
+"""The shared tool loop for API backends.
+
+An Adapter speaks one wire protocol and keeps its own native message list (`state`). The loop
+asks it for one model step at a time, runs any tool calls, and feeds the results back.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+
+from attache.types import Endpoint, Reply, Tool, ToolCall, Turn
+
+MAX_STEPS = 20
+MAX_TOOL_OUTPUT = 20_000  # characters; longer results are cut with a note saying so
+
+
+@dataclass
+class Step:
+    text: str
+    calls: list[ToolCall] = field(default_factory=list)
+    usage: dict[str, Any] = field(default_factory=dict)
+
+
+class Adapter(Protocol):
+    def start(self, turn: Turn) -> Any:
+        """Build the native message list from turn.history and turn.text."""
+        ...
+
+    async def step(self, state: Any, turn: Turn) -> Step:
+        """One model call with turn.system and turn.tools. Appends the model's message to state."""
+        ...
+
+    def add_results(self, state: Any, results: list[tuple[ToolCall, str]]) -> None:
+        """Append tool results in the protocol's native form."""
+        ...
+
+
+def api_key(endpoint: Endpoint) -> str | None:
+    """The value of $key_env, or None when no key_env is set; RuntimeError when it is empty."""
+    env = endpoint.key_env
+    if env and not os.environ.get(env):
+        raise RuntimeError(f"endpoint '{endpoint.name}' needs the {env} environment variable")
+    return os.environ[env] if env else None
+
+
+def tool_spec(tool: Tool, key: str = "parameters") -> dict[str, Any]:
+    """{"name", "description", <key>: schema}; Anthropic and MCP call the schema key differently."""
+    return {"name": tool.name, "description": tool.description, key: tool.schema}
+
+
+async def run_tool(call: ToolCall, turn: Turn) -> str:
+    """Run one call against turn.tools. Unknown tools and exceptions become "error: ..." text,
+    never exceptions, so the model can recover. Output is capped at MAX_TOOL_OUTPUT."""
+    if "__error__" in call.args:  # set by adapters when the model sent malformed arguments
+        return f"error: {call.args['__error__']}"
+    tool = next((t for t in turn.tools if t.name == call.name), None)
+    if tool is None:
+        return f"error: unknown tool {call.name!r}"
+    try:
+        out = await tool.fn(call.args, turn.ctx)
+    except Exception as e:
+        return f"error: {type(e).__name__}: {e}"
+    if len(out) > MAX_TOOL_OUTPUT:
+        out = f"{out[:MAX_TOOL_OUTPUT]}\n[cut: showing {MAX_TOOL_OUTPUT} of {len(out)} characters]"
+    return out
+
+
+async def tool_loop(adapter: Adapter, turn: Turn, max_steps: int = MAX_STEPS) -> Reply:
+    """Step until the model stops calling tools or max_steps is hit (then say so in the reply).
+    Usage from every step is summed into Reply.usage."""
+    state = adapter.start(turn)
+    usage: dict[str, Any] = {}
+    text = ""
+    for _ in range(max_steps):
+        step = await adapter.step(state, turn)
+        for key, value in step.usage.items():
+            usage[key] = usage.get(key, 0) + (value or 0)
+        text = step.text or text
+        if not step.calls:
+            return Reply(step.text, usage=usage)
+        results = [(call, await run_tool(call, turn)) for call in step.calls]
+        adapter.add_results(state, results)
+    return Reply(f"{text}\n\n(I stopped after {max_steps} steps.)".lstrip(), usage=usage)

attache/app.py

@@ -0,0 +1,82 @@
+"""Wire the services together and run them."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import secrets
+from dataclasses import dataclass, field
+from pathlib import Path
+from socket import AF_INET, AF_INET6, create_server, socket
+
+from attache import channels, config, router, scheduler, store, web
+from attache.types import Turn
+
+
+@dataclass
+class Services:
+    config: config.Config
+    store: store.Store
+    scheduler: scheduler.Scheduler
+    channels: channels.ChannelManager
+    gateway: dict[str, Turn]  # MCP token -> the turn it serves (the claude-cli backend's tools)
+    web_url: str  # e.g. http://127.0.0.1:8765
+    ui_token: str = field(default_factory=lambda: secrets.token_urlsafe(24))  # new every run
+
+    @property
+    def home(self) -> Path:
+        return self.config.home
+
+
+def listen(cfg: config.Config) -> socket:
+    """Bind [web] host:port. Phase 1 serves this machine only: another host is a SystemExit.
+    A port in use raises OSError."""
+    if cfg.host not in ("127.0.0.1", "localhost", "::1"):
+        raise SystemExit(f"[web] host = {cfg.host!r}: use 127.0.0.1, localhost or ::1 for now")
+    return create_server((cfg.host, cfg.port), family=AF_INET6 if cfg.host == "::1" else AF_INET)
+
+
+def build(home: Path) -> Services:
+    """Load config and open the store. No network, no tasks started."""
+    cfg = config.load(home)
+    db = store.Store(home / "attache.db")
+    url = f"http://{'[::1]' if cfg.host == '::1' else cfg.host}:{cfg.port}"
+    return Services(cfg, db, scheduler.Scheduler(db), channels.ChannelManager(), {}, url)
+
+
+async def run(home: Path, *, terminal: bool) -> None:
+    """Start the web server, scheduler and channels (plus the terminal chat when asked).
+
+    Returns when any task ends: the terminal chat's, at EOF or /quit, is the normal one; the
+    others only stop by failing. Ctrl+C also returns. A port in use or a host that is not this
+    machine is a SystemExit saying so; so is the web server stopping. On the way out every
+    task is cancelled and awaited (any that failed is logged), the channels are stopped, and
+    only then is the store closed. fire is set before the scheduler starts: no wake() needed."""
+    cfg = config.load(home)
+    try:
+        sock = listen(cfg)
+    except OSError:
+        raise SystemExit(f"Port {cfg.port} is in use. Is `attache run` already running?") from None
+    services = build(home)
+    rt, page = router.Router(services), web.WebChannel()  # rt sets itself as scheduler.fire
+    url = f"{services.web_url}/#t={services.ui_token}"
+    print(f"Open {url}", flush=True)
+    services.channels.add(page)
+    if terminal:
+        services.channels.add(channels.TerminalChannel(cfg.owner.name, url))
+    server = asyncio.create_task(web.serve(web.create_app(services, rt, page), sock))
+    tasks = [server, asyncio.create_task(services.scheduler.run())]
+    tasks += await services.channels.start(rt.handle)
+    try:
+        done, _ = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+        if server in done:
+            raise SystemExit("The web server stopped.")
+    finally:
+        everything = [*tasks, *rt.background.values()]  # background: scheduled turns running
+        for task in everything:
+            task.cancel()
+        for result in await asyncio.gather(*everything, return_exceptions=True):
+            if isinstance(result, Exception):
+                logging.getLogger(__name__).error("a task failed", exc_info=result)
+        await services.channels.stop()
+        services.store.close()

attache/backends/__init__.py

@@ -0,0 +1,40 @@
+"""Pick a backend for an endpoint."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from attache.agent import Adapter, tool_loop
+from attache.backends.anthropic import AnthropicAdapter
+from attache.backends.claude_cli import ClaudeCLI
+from attache.backends.openai import ChatAdapter, ResponsesAdapter
+from attache.types import Backend, Endpoint, Reply, Turn
+
+ADAPTERS = {
+    "anthropic": AnthropicAdapter,
+    "openai-chat": ChatAdapter,
+    "openai-responses": ResponsesAdapter,
+}
+
+
+@dataclass
+class APIBackend:
+    adapter: Adapter
+
+    async def run(self, turn: Turn) -> Reply:
+        return await tool_loop(self.adapter, turn)
+
+
+def make(endpoint: Endpoint) -> Backend:
+    """anthropic | openai-chat | openai-responses -> tool_loop over that adapter;
+    claude-cli -> ClaudeCLI. Unknown api names raise ValueError listing the valid ones.
+    SDK clients are created lazily so a missing API key fails at the first turn, with a
+    message naming the endpoint and its key_env."""
+    if endpoint.api == "claude-cli":
+        return ClaudeCLI(endpoint)
+    if endpoint.api not in ADAPTERS:
+        valid = ", ".join([*ADAPTERS, "claude-cli"])
+        raise ValueError(
+            f"endpoint '{endpoint.name}' has unknown api '{endpoint.api}'; use {valid}"
+        )
+    return APIBackend(ADAPTERS[endpoint.api](endpoint))

attache/backends/anthropic.py

@@ -0,0 +1,62 @@
+"""Anthropic Messages API adapter, for the Claude API and any Anthropic-compatible base_url."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from attache.agent import Step, api_key, tool_spec
+from attache.types import Endpoint, ToolCall, Turn
+
+
+class AnthropicAdapter:
+    def __init__(self, endpoint: Endpoint, client: Any = None) -> None:
+        """client: an AsyncAnthropic-like object; tests pass a fake. None builds one lazily from
+        endpoint.base_url and the env var named by endpoint.key_env."""
+        self.endpoint = endpoint
+        self.client = client
+
+    def _client(self) -> Any:
+        if self.client is None:
+            key = api_key(self.endpoint)
+            import anthropic
+
+            self.client = anthropic.AsyncAnthropic(api_key=key, base_url=self.endpoint.base_url)
+        return self.client
+
+    def start(self, turn: Turn) -> list[dict[str, Any]]:
+        # The API wants strict user/assistant alternation that opens with a user message.
+        msgs: list[dict[str, Any]] = []
+        for m in [*turn.history, {"role": "user", "content": turn.text}]:
+            if msgs and msgs[-1]["role"] == m["role"]:
+                msgs[-1]["content"] += "\n\n" + m["content"]
+            elif msgs or m["role"] == "user":
+                msgs.append({"role": m["role"], "content": m["content"]})
+        return msgs
+
+    async def step(self, state: list[dict[str, Any]], turn: Turn) -> Step:
+        tools = [tool_spec(t, key="input_schema") for t in turn.tools]
+        resp = await self._client().messages.create(
+            model=self.endpoint.model,
+            max_tokens=self.endpoint.options.get("max_tokens", 4096),
+            system=turn.system,
+            messages=state,
+            **({"tools": tools} if tools else {}),
+        )
+        # Send the blocks back as they came, so thinking blocks keep their signatures.
+        blocks = [b.model_dump(exclude_none=True) for b in resp.content]
+        state.append({"role": "assistant", "content": blocks})
+        return Step(
+            text="".join(b.text for b in resp.content if b.type == "text"),
+            calls=[ToolCall(b.id, b.name, b.input) for b in resp.content if b.type == "tool_use"],
+            usage={
+                "input_tokens": resp.usage.input_tokens,
+                "output_tokens": resp.usage.output_tokens,
+            },
+        )
+
+    def add_results(self, state: list[dict[str, Any]], results: list[tuple[ToolCall, str]]) -> None:
+        blocks = [
+            {"type": "tool_result", "tool_use_id": call.id, "content": output}
+            for call, output in results
+        ]
+        state.append({"role": "user", "content": blocks})

attache/backends/claude_cli.py

@@ -0,0 +1,160 @@
+"""Claude Code as a backend: `claude -p` runs its own tool loop and reaches our tools over MCP.
+
+Only the owner's turns may use it, because a Claude subscription login is for your own use
+(Anthropic's terms). The message goes on stdin, which avoids Windows command-line length
+limits. claude runs in a private directory next to <home> ("<home>-claude"), with <home> added
+by --add-dir, so a CLAUDE.md or .claude/settings.json (hooks) planted in <home> is never loaded
+as project config; Claude Code looks for those in its working directory and the ones above it.
+That directory stays the same across turns so every session is in one Claude Code project and
+--resume finds it. The user's own ~/.claude config still applies; that is the owner's choice.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import os
+import secrets
+import shutil
+import tempfile
+from collections.abc import AsyncIterator, Iterable
+from dataclasses import replace
+from pathlib import Path
+from typing import Any
+
+from attache.types import Endpoint, Reply, Turn
+
+OWNER_BUILTINS = ["Read", "Write", "Edit", "Glob", "Grep", "Bash", "WebFetch", "WebSearch"]
+# Our tools that Claude Code's own Read/Write/Edit/Bash already cover, so they are not served.
+DUPLICATE_TOOLS = {"read_file", "write_file", "edit_file", "run"}
+# Errors a fresh session fixes: an unknown --resume id, or a conversation past the context limit.
+RESET_ON = ("no conversation found", "prompt is too long", "context window", "context length")
+SCRATCH = "Your working directory is a scratch folder. Every relative path below is relative to"
+
+
+class StaleSessionError(RuntimeError):
+    """The resumed session can't go on, and no tool ran, so a fresh session can safely retry."""
+
+
+async def _spawn(argv: list[str], text: str, cwd: Path, env: dict[str, str]) -> AsyncIterator[str]:
+    pipe = asyncio.subprocess.PIPE
+    proc = await asyncio.create_subprocess_exec(
+        *argv, cwd=cwd, env=env, stdin=pipe, stdout=pipe, stderr=pipe, limit=2**24
+    )
+    try:
+        stderr = asyncio.ensure_future(proc.stderr.read())  # drain so a full pipe can't block it
+        with contextlib.suppress(ConnectionError):  # it exited early; stderr says why
+            proc.stdin.write(text.encode("utf-8"))
+            await proc.stdin.drain()
+            proc.stdin.close()
+        got_result = False
+        async for raw in proc.stdout:
+            line = raw.decode("utf-8", "replace")
+            got_result = got_result or '"type":"result"' in line.replace(" ", "")
+            yield line
+        code = await proc.wait()
+        if code and not got_result:
+            tail = (await stderr).decode("utf-8", "replace").strip()[-2000:]
+            raise RuntimeError(f"claude exited with code {code}: {tail}")
+    finally:
+        if proc.returncode is None:
+            proc.kill()
+
+
+def _env() -> dict[str, str]:
+    """os.environ, with our local MCP traffic kept off proxies and room for 10-minute tools."""
+    skip = os.environ.get("NO_PROXY") or os.environ.get("no_proxy")
+    no_proxy = ",".join(filter(None, [skip, "127.0.0.1,localhost,::1"]))
+    env = {**os.environ, "NO_PROXY": no_proxy, "no_proxy": no_proxy, "MCP_TOOL_TIMEOUT": "660000"}
+    env.pop("CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD", None)  # keep <home>'s CLAUDE.md out
+    return env
+
+
+def prompt(turn: Turn) -> str:
+    """turn.text after a fenced transcript of the history this Claude session hasn't seen: all
+    of it (the last 30 messages, 20,000 characters) when fresh, else what followed its last reply.
+    """
+    history, label = turn.history, "Earlier messages in this chat"
+    replies = [i for i, m in enumerate(history) if m["role"] == "assistant"]
+    if turn.session.get("session_id") and replies:
+        history, label = history[replies[-1] + 1 :], "Messages in this chat since your last reply"
+    body = "\n\n".join(f"{m['role']}: {m['content']}" for m in history[-30:])[-20_000:]
+    if not body:
+        return turn.text
+    fence = "```"
+    while fence in body:  # longer than any run of backticks inside, so the text can't close it
+        fence += "`"
+    return f"{label}, oldest first:\n{fence}\n{body}\n{fence}\n\nNew message:\n{turn.text}"
+
+
+class ClaudeCLI:
+    def __init__(self, endpoint: Endpoint, runner: Any = None) -> None:
+        """runner(argv, stdin_text, cwd, env) -> async iterable of stdout lines; tests pass one."""
+        self.endpoint, self.runner = endpoint, runner or _spawn
+
+    def command(self, turn: Turn, mcp_config: Path, system_file: Path) -> list[str]:
+        name = self.endpoint.options.get("bin", "claude")
+        if not (exe := shutil.which(name)):
+            raise RuntimeError(f"endpoint '{self.endpoint.name}': claude binary {name!r} not found")
+        argv = [exe, "-p", "--output-format", "stream-json", "--verbose"]
+        argv += ["--model", self.endpoint.model, "--append-system-prompt-file", str(system_file)]
+        argv += ["--mcp-config", str(mcp_config), "--strict-mcp-config"]
+        argv += ["--add-dir", str(turn.ctx.services.home)]
+        argv += ["--allowedTools", ",".join([*OWNER_BUILTINS, "mcp__attache"])]
+        if session_id := turn.session.get("session_id"):
+            argv += ["--resume", session_id]
+        return argv
+
+    async def run(self, turn: Turn) -> Reply:
+        if turn.ctx.role != "owner" or turn.ctx.is_group:  # groups carry untrusted text
+            raise PermissionError("the claude-cli backend only answers the owner's own chats")
+        services = turn.ctx.services
+        token = secrets.token_urlsafe(24)
+        cwd = services.home.parent / f"{services.home.name}-claude"  # outside <home>: see above
+        cwd.mkdir(exist_ok=True)
+        files = Path(tempfile.mkdtemp(prefix="attache-"))  # this turn's MCP config and prompt
+        try:
+            tools = [t for t in turn.tools if t.name not in DUPLICATE_TOOLS]
+            services.gateway[token] = replace(turn, tools=tools)
+            server = {"type": "http", "url": f"{services.web_url}/mcp/{token}"}
+            config = json.dumps({"mcpServers": {"attache": server}})
+            (files / "mcp.json").write_text(config, encoding="utf-8")
+            system = f"{SCRATCH} {services.home}; use absolute paths under it.\n\n{turn.system}"
+            (files / "system.md").write_text(system, encoding="utf-8")
+            try:
+                return await self._once(turn, files, cwd)
+            except StaleSessionError:
+                if not turn.session.get("session_id"):
+                    raise
+                return await self._once(replace(turn, session={}), files, cwd)  # full transcript
+        finally:
+            services.gateway.pop(token, None)
+            shutil.rmtree(files, ignore_errors=True)
+
+    async def _once(self, turn: Turn, files: Path, cwd: Path) -> Reply:
+        argv = self.command(turn, files / "mcp.json", files / "system.md")
+        return parse_events([line async for line in self.runner(argv, prompt(turn), cwd, _env())])
+
+
+def parse_events(lines: Iterable[str]) -> Reply:
+    """Reply.text from the final "result" event (fall back to joined assistant text blocks),
+    Reply.session = {"session_id": ...}, Reply.usage = {"cost_usd": ..., ...}. A result with
+    is_error true raises RuntimeError with its message (StaleSessionError when a fresh session would
+    fix it and no tool has run yet, since running tools twice could repeat a send or a write).
+    Non-JSON lines are ignored."""
+    events = []
+    for line in lines:
+        with contextlib.suppress(ValueError):
+            events.append(json.loads(line))
+    result = next((e for e in reversed(events) if e.get("type") == "result"), {})
+    blocks = [b for e in events if e.get("type") == "assistant" for b in e["message"]["content"]]
+    if result.get("is_error"):
+        message = result.get("result") or "; ".join(result.get("errors") or ["claude failed"])
+        used_tools = any(b.get("type") == "tool_use" for b in blocks)
+        stale = not used_tools and any(s in message.lower() for s in RESET_ON)
+        raise (StaleSessionError if stale else RuntimeError)(message)
+    usage = {k: (result.get("usage") or {}).get(k) for k in ("input_tokens", "output_tokens")}
+    usage["cost_usd"] = result.get("total_cost_usd")
+    text = result.get("result") or "\n\n".join(b["text"] for b in blocks if b.get("type") == "text")
+    return Reply(text, {"session_id": result.get("session_id")}, usage)

attache/backends/openai.py

@@ -0,0 +1,101 @@
+"""OpenAI adapters, both on openai.AsyncOpenAI with endpoint.base_url.
+
+ChatAdapter speaks Chat Completions, the format most custom endpoints share (Ollama, vLLM,
+LM Studio, llama.cpp, OpenRouter, Groq, Azure v1). ResponsesAdapter speaks the Responses API,
+which OpenAI's reasoning models need for tool calls.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+from typing import Any
+
+from attache.agent import Step, api_key, tool_spec
+from attache.types import Endpoint, ToolCall, Turn
+
+
+def _client(adapter: ChatAdapter | ResponsesAdapter) -> Any:
+    if adapter.client is None:
+        key = api_key(adapter.endpoint) or "not-needed"  # local servers take any key
+        from openai import AsyncOpenAI
+
+        adapter.client = AsyncOpenAI(api_key=key, base_url=adapter.endpoint.base_url)
+    return adapter.client
+
+
+def _args(raw: Any) -> dict[str, Any]:
+    """Parsed tool-call arguments; malformed ones become {"__error__": ...} for run_tool."""
+    if isinstance(raw, dict):  # some local servers send an object, not a JSON string
+        return raw
+    with contextlib.suppress(ValueError):
+        if isinstance(args := json.loads(raw or "{}"), dict):
+            return args
+    return {"__error__": f"arguments were not valid JSON: {(raw or '')[:200]}"}
+
+
+class ChatAdapter:
+    def __init__(self, endpoint: Endpoint, client: Any = None) -> None:
+        self.endpoint = endpoint
+        self.client = client
+
+    def start(self, turn: Turn) -> list[dict[str, Any]]:
+        return [
+            {"role": "system", "content": turn.system},
+            *map(dict, turn.history),
+            {"role": "user", "content": turn.text},
+        ]
+
+    async def step(self, state: list[dict[str, Any]], turn: Turn) -> Step:
+        kwargs: dict[str, Any] = {"model": self.endpoint.model, "messages": state}
+        if turn.tools:
+            kwargs["tools"] = [{"type": "function", "function": tool_spec(t)} for t in turn.tools]
+        resp = await _client(self).chat.completions.create(**kwargs)
+        msg = resp.choices[0].message
+        tool_calls = msg.tool_calls or []
+        message: dict[str, Any] = {"role": "assistant", "content": msg.content}
+        if tool_calls:
+            message["tool_calls"] = [tc.model_dump(exclude_none=True) for tc in tool_calls]
+        state.append(message)
+        calls = [
+            ToolCall(tc.id, tc.function.name, _args(tc.function.arguments)) for tc in tool_calls
+        ]
+        u = resp.usage  # some local servers omit it
+        usage = {"input_tokens": u.prompt_tokens, "output_tokens": u.completion_tokens} if u else {}
+        return Step(msg.content or "", calls, usage)
+
+    def add_results(self, state: list[dict[str, Any]], results: list[tuple[ToolCall, str]]) -> None:
+        for call, output in results:
+            state.append({"role": "tool", "tool_call_id": call.id, "content": output})
+
+
+class ResponsesAdapter:
+    def __init__(self, endpoint: Endpoint, client: Any = None) -> None:
+        self.endpoint = endpoint
+        self.client = client
+
+    def start(self, turn: Turn) -> list[dict[str, Any]]:
+        return [*map(dict, turn.history), {"role": "user", "content": turn.text}]
+
+    async def step(self, state: list[dict[str, Any]], turn: Turn) -> Step:
+        resp = await _client(self).responses.create(
+            model=self.endpoint.model,
+            instructions=turn.system,
+            input=state,
+            # strict mode would reject schemas with optional fields, so turn it off
+            tools=[{"type": "function", **tool_spec(t), "strict": False} for t in turn.tools],
+            store=False,  # stateless: reasoning comes back encrypted and is replayed from state
+            include=["reasoning.encrypted_content"],
+        )
+        calls = []
+        for item in resp.output:
+            state.append(item.model_dump(exclude_none=True))
+            if item.type == "function_call":
+                calls.append(ToolCall(item.call_id, item.name, _args(item.arguments)))
+        u = resp.usage
+        usage = {"input_tokens": u.input_tokens, "output_tokens": u.output_tokens} if u else {}
+        return Step(resp.output_text or "", calls, usage)
+
+    def add_results(self, state: list[dict[str, Any]], results: list[tuple[ToolCall, str]]) -> None:
+        for call, output in results:
+            state.append({"type": "function_call_output", "call_id": call.id, "output": output})

attache/bundled/attache.toml

@@ -0,0 +1,56 @@
+# Attaché settings. Restart `attache run` after editing.
+# People and chats are keyed by platform ids, never by display names.
+
+[assistant]
+name = "Attaché"  # how the assistant names itself; also its trigger word in group chats
+
+[owner]
+name = "{owner}"
+
+# Your own sender id on each chat app, so your direct messages there reach you as the owner.
+# Ids can also go straight in [owner] (or [people.<id>]), like slack = "U0123".
+[owner.ids]
+slack = ""
+
+[routing]
+own_chats = "{endpoint}"    # your own chat (terminal and web) and your direct messages
+group_chats = "claude-api"  # group chats, and anyone but you
+
+[web]
+host = "127.0.0.1"  # only this machine can reach the web page
+port = 8765
+
+# Models. api: anthropic | openai-chat | openai-responses | claude-cli. Other keys, such as
+# max_tokens, are passed to the backend as options.
+[endpoints.claude]
+api = "claude-cli"  # your Claude Code login
+model = "claude-sonnet-5-5"
+
+[endpoints.claude-api]
+api = "anthropic"
+model = "claude-sonnet-5-5"
+key_env = "ANTHROPIC_API_KEY"
+
+# [endpoints.openai]
+# api = "openai-responses"
+# model = "gpt-5.4"
+# key_env = "OPENAI_API_KEY"
+
+# [endpoints.local]
+# api = "openai-chat"
+# base_url = "http://localhost:11434/v1"
+# model = "qwen3:32b"
+
+# People you share chats with. Keys other than name, role and ids are their ids per chat app.
+# [people.sam]
+# name = "Sam"
+# role = "member"  # member | guest
+# slack = "U0123"
+
+# Group chats Attaché answers in, keyed "<channel>:<chat id>". Unlisted groups are ignored.
+# [chats."slack:C0123"]
+# name = "Family"
+# engage = "mention"  # mention | always | a regular expression matched against the text
+# members = ["sam"]   # person ids from [people]
+# guests = "ignore"   # ignore | public
+# endpoint = "claude-api"

attache/bundled/memory/ATTACHE.md

@@ -0,0 +1,11 @@
+# Attaché
+
+You are Attaché, {owner}'s personal assistant. This file is your persona; {owner} can edit it.
+
+- Be concise and warm. Answer first, then offer more if it would help.
+- Ask before you send email, delete anything, or message any chat other than this one.
+- Read a skill's SKILL.md before you use the skill.
+- Use an artifact for lists, boards and anything interactive.
+- Use `schedule` for reminders and anything that should happen later.
+- When {owner} shares a lasting fact or preference, keep the notes in `memory/` up to date:
+  USER.md for {owner}, `memory/chats/` for a chat.

attache/bundled/memory/USER.md

@@ -0,0 +1,18 @@
+# {owner}
+
+What Attaché knows about you. Edit freely; Attaché adds to it when you share lasting facts.
+
+- Name: {owner}
+- Time zone:
+- Languages:
+
+## Preferences
+
+- How you like replies (short, detailed, bullet points):
+- Working hours:
+
+## VIPs
+
+People whose messages matter most, and how you know them.
+
+-