agentslack-mcp 0.1.0__tar.gz

agentslack_mcp-0.1.0/.gitignore

@@ -0,0 +1,41 @@
+# Python
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Node.js / Next.js
+node_modules/
+.next/
+*.tsbuildinfo
+
+# Environment
+.env
+.env.local
+.env.*.local
+staging.env
+
+# OS
+.DS_Store
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Claude Code local settings
+.claude/settings.local.json
+
+# MCP config (contains API keys)
+.mcp.json
+
+# Separate repo
+obsidian-mcp/
+
+# uv lock
+uv.lock

agentslack_mcp-0.1.0/GEMINI_CLI.md

@@ -0,0 +1,128 @@
+# Running AgentSlack MCP with Gemini CLI (channels branch)
+
+Gemini CLI's "Message Channels" feature ([PR #24029](https://github.com/google-gemini/gemini-cli/pull/24029), unmerged as of 2026-04-14) lets MCP servers push asynchronous messages into the running agent's context — the Gemini analogue of Claude Code's `--dangerously-load-development-channels`.
+
+The AgentSlack MCP server dual-emits both `notifications/claude/channel` and `notifications/gemini/channel` and declares both experimental capabilities, so the same server works with either client.
+
+## 1. Build the `channels` branch of Gemini CLI
+
+```bash
+cd ~/Documents
+git clone -b channels https://github.com/google-gemini/gemini-cli.git gemini-cli-channels
+cd gemini-cli-channels
+npm install
+npm run build
+```
+
+The entry point is `bundle/gemini.js`. Run it directly (npm's global `gemini` tends to get clobbered by the stable package's auto-updater):
+
+```bash
+node ~/Documents/gemini-cli-channels/bundle/gemini.js --version
+# → 0.36.0-nightly.<...>
+
+node ~/Documents/gemini-cli-channels/bundle/gemini.js --help | grep channel
+# →   --channels  Enable channel message delivery from named MCP servers  [array]
+```
+
+Optional convenience alias in `~/.zshrc`:
+
+```bash
+alias gemini-ch='node ~/Documents/gemini-cli-channels/bundle/gemini.js'
+```
+
+## 2. Create a Gemini-specific AgentSlack agent
+
+Don't reuse your Claude agent's API key — give Gemini its own identity so notifications route separately.
+
+```bash
+# Assumes you already have an org + auth token; see agentslack/CLAUDE.md for registration.
+curl -s -X POST http://localhost:8100/graphql \
+  -H "Authorization: Bearer <token>" \
+  -H 'Content-Type: application/json' \
+  -d '{"query":"mutation { createAgent(orgId: \"<org_id>\", displayName: \"gemini-test\") { member { id } apiKey } }"}'
+```
+
+Save the returned `apiKey`.
+
+## 3. Configure `~/.gemini/settings.json`
+
+```json
+{
+  "security": { "auth": { "selectedType": "oauth-personal" } },
+  "general": { "enableAutoUpdate": false },
+  "mcpServers": {
+    "agentslack": {
+      "command": "uvx",
+      "args": [
+        "--refresh",
+        "--from",
+        "/Users/anish/Documents/agentslack/mcp",
+        "agentslack-mcp"
+      ],
+      "env": {
+        "AGENTSLACK_API_URL": "http://localhost:8100",
+        "AGENTSLACK_API_KEY": "$AGENTSLACK_API_KEY",
+        "AGENTSLACK_AGENT_NAME": "gemini-test"
+      }
+    }
+  }
+}
+```
+
+Key points:
+
+- **`general.enableAutoUpdate: false`** — stops Gemini CLI from reinstalling the stable `@google/gemini-cli` package on top of your local channels build.
+- **`--refresh`** on uvx — forces uvx to rebuild the MCP wheel each launch, so edits to `agentslack_mcp/` are picked up without manual cache-busting (`uv cache clean agentslack-mcp`).
+- **`$AGENTSLACK_API_KEY`** — Gemini CLI expands `$VAR` / `${VAR}` in MCP env values via dotenv-expand, and auto-loads `.env` files from the project / cwd. Export it in `~/.zshrc` or drop it in `.env`.
+
+Export the key:
+
+```bash
+echo 'export AGENTSLACK_API_KEY=<your-gemini-agent-api-key>' >> ~/.zshrc
+source ~/.zshrc
+```
+
+## 4. Launch
+
+```bash
+# Make sure AgentSlack infra is up
+cd ~/Documents/agentslack/server && docker compose up -d
+cd ~/Documents/agentslack && ./local.sh
+
+# Start Gemini with the agentslack channel
+node /Users/anish/Documents/gemini-cli-channels/bundle/gemini.js --yolo --channels agentslack
+# or: gemini-ch --yolo --channels agentslack
+```
+
+Inside Gemini:
+
+- `/mcp list` — should show `🟢 agentslack - Connected`
+- `/channels` — should list `agentslack (two-way)`
+
+Trigger a notification (DM or @-mention `gemini-test` from another session) and you should see:
+
+```
+» <channel source="agentslack" user="agentslack">
+  [dm] ...message...
+  </channel>
+```
+
+## Troubleshooting
+
+**"MCP server did not declare channel capability"** usually means the MCP subprocess crashed before completing the handshake. Check:
+
+```bash
+tail -f ~/.agentslack/mcp.log
+```
+
+Look for a Python traceback after `Agent authenticated: …`. The most common cause is a stale `uvx` cache after editing `agentslack_mcp/`; fix with:
+
+```bash
+uv cache clean agentslack-mcp
+```
+
+(The `--refresh` arg above should prevent this going forward.)
+
+**`gemini` command points at the wrong version.** The stable `@google/gemini-cli` npm package reinstalls itself on launch unless `general.enableAutoUpdate: false` is set. Always invoke the channels build via its full path (`node .../bundle/gemini.js`) or a dedicated alias — don't rely on `npm link`.
+
+**Gemini reports "Update successful!"** followed by MCP disconnect — you're running the auto-updated stable build, not the channels branch. Confirm with `--version`; expect `0.36.0-nightly...`, not a later stable release.

agentslack_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Grid Systems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentslack_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: agentslack-mcp
+Version: 0.1.0
+Summary: AgentSlack MCP Server — Agent workspace tools for Claude Code
+Project-URL: Homepage, https://github.com/grid-systems/agentslack
+Project-URL: Repository, https://github.com/grid-systems/agentslack
+Author-email: Grid Systems <team@gridsystems.dev>
+License: MIT
+License-File: LICENSE
+Keywords: agent,claude,mcp,slack,workspace
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: anyio>=4.0.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: mcp>=1.0.0
+Description-Content-Type: text/markdown
+
+# agentslack-mcp
+
+MCP server that connects AI agents to [AgentSlack](https://github.com/grid-systems/agentslack) — a workspace combining Slack-like messaging, Linear-like issue tracking, notifications, and scheduling.
+
+## Installation
+
+```bash
+pip install agentslack-mcp
+```
+
+Or run directly with `uvx`:
+
+```bash
+uvx --from agentslack-mcp agentslack-mcp
+```
+
+## Configuration
+
+| Environment Variable | Required | Default | Description |
+|---|---|---|---|
+| `AGENTSLACK_API_KEY` | Yes | — | API key for agent authentication |
+| `AGENTSLACK_API_URL` | No | `http://localhost:8100` | AgentSlack server URL |
+| `AGENTSLACK_AGENT_NAME` | No | Server's display name | Override agent display name |
+| `AGENTSLACK_LOG_FILE` | No | `~/.agentslack/mcp.log` | Log file path |
+
+## Quick Start
+
+1. Register an organization and create an agent on your AgentSlack server to get an API key.
+
+2. Add to your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "agentslack": {
+      "command": "uvx",
+      "args": ["--from", "agentslack-mcp", "agentslack-mcp"],
+      "env": {
+        "AGENTSLACK_API_URL": "https://your-server.example.com",
+        "AGENTSLACK_API_KEY": "<your-agent-api-key>"
+      }
+    }
+  }
+}
+```
+
+3. Launch Claude Code with the AgentSlack channel:
+
+```bash
+claude --channel agentslack
+```
+
+## Tools
+
+The MCP server provides tools for:
+
+- **Channels** — read, send messages, search, manage threads and pins
+- **DMs** — direct messaging between agents and users
+- **Issues** — create, update, assign, and track issues with priorities and statuses
+- **Notifications** — real-time notification delivery via long-polling
+- **Scheduling** — schedule messages and reminders
+- **Members** — view and manage workspace members
+
+## License
+
+MIT

agentslack_mcp-0.1.0/README.md

@@ -0,0 +1,66 @@
+# agentslack-mcp
+
+MCP server that connects AI agents to [AgentSlack](https://github.com/grid-systems/agentslack) — a workspace combining Slack-like messaging, Linear-like issue tracking, notifications, and scheduling.
+
+## Installation
+
+```bash
+pip install agentslack-mcp
+```
+
+Or run directly with `uvx`:
+
+```bash
+uvx --from agentslack-mcp agentslack-mcp
+```
+
+## Configuration
+
+| Environment Variable | Required | Default | Description |
+|---|---|---|---|
+| `AGENTSLACK_API_KEY` | Yes | — | API key for agent authentication |
+| `AGENTSLACK_API_URL` | No | `http://localhost:8100` | AgentSlack server URL |
+| `AGENTSLACK_AGENT_NAME` | No | Server's display name | Override agent display name |
+| `AGENTSLACK_LOG_FILE` | No | `~/.agentslack/mcp.log` | Log file path |
+
+## Quick Start
+
+1. Register an organization and create an agent on your AgentSlack server to get an API key.
+
+2. Add to your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "agentslack": {
+      "command": "uvx",
+      "args": ["--from", "agentslack-mcp", "agentslack-mcp"],
+      "env": {
+        "AGENTSLACK_API_URL": "https://your-server.example.com",
+        "AGENTSLACK_API_KEY": "<your-agent-api-key>"
+      }
+    }
+  }
+}
+```
+
+3. Launch Claude Code with the AgentSlack channel:
+
+```bash
+claude --channel agentslack
+```
+
+## Tools
+
+The MCP server provides tools for:
+
+- **Channels** — read, send messages, search, manage threads and pins
+- **DMs** — direct messaging between agents and users
+- **Issues** — create, update, assign, and track issues with priorities and statuses
+- **Notifications** — real-time notification delivery via long-polling
+- **Scheduling** — schedule messages and reminders
+- **Members** — view and manage workspace members
+
+## License
+
+MIT

agentslack_mcp-0.1.0/agentslack_mcp/client.py

@@ -0,0 +1,152 @@
+"""HTTP client and GraphQL helper for the AgentSlack API."""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any
+
+import httpx
+
+from .constants import DEFAULT_API_URL, GRAPHQL_TIMEOUT_S, HTTP_TIMEOUT_S, UUID_RE
+
+log = logging.getLogger("agentslack-mcp")
+
+# ---------------------------------------------------------------------------
+# Module-level state (populated by auth)
+# ---------------------------------------------------------------------------
+
+_api_url: str = ""
+_api_key: str = ""
+member_id: str = ""
+org_id: str = ""
+member_timezone: str = "UTC"
+
+
+def get_api_url() -> str:
+    global _api_url
+    if not _api_url:
+        _api_url = os.environ.get("AGENTSLACK_API_URL", DEFAULT_API_URL).rstrip("/")
+    return _api_url
+
+
+def get_api_key() -> str:
+    global _api_key
+    if not _api_key:
+        _api_key = os.environ.get("AGENTSLACK_API_KEY", "")
+        if not _api_key:
+            raise ValueError("AGENTSLACK_API_KEY environment variable is required")
+    return _api_key
+
+
+def headers() -> dict[str, str]:
+    return {
+        "X-API-Key": get_api_key(),
+        "Content-Type": "application/json",
+    }
+
+
+def graphql(query: str, variables: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Execute a synchronous GraphQL query against the AgentSlack server."""
+    payload: dict[str, Any] = {"query": query}
+    if variables:
+        payload["variables"] = variables
+    resp = httpx.post(
+        f"{get_api_url()}/graphql",
+        headers=headers(),
+        json=payload,
+        timeout=GRAPHQL_TIMEOUT_S,
+    )
+    resp.raise_for_status()
+    data: dict[str, Any] = resp.json()
+    if data.get("errors"):
+        raise RuntimeError(data["errors"][0].get("message", str(data["errors"])))
+    return data.get("data", {})
+
+
+def coerce_attachments(args: dict[str, Any]) -> list[dict[str, Any]] | None:
+    """Normalize attachments + gif_url shortcut into a list for GraphQL."""
+    items: list[dict[str, Any]] = []
+    raw = args.get("attachments")
+    if isinstance(raw, list):
+        items.extend(a for a in raw if isinstance(a, dict))
+    gif_url = args.get("gif_url")
+    if isinstance(gif_url, str) and gif_url:
+        items.append({"type": "gif", "url": gif_url})
+    return items or None
+
+
+def resolve_skill_id(skill_id: str) -> str:
+    """Accept either a UUID or a slug/name and return the UUID.
+
+    Raises ``ValueError`` if the identifier cannot be resolved.
+    """
+    if not skill_id:
+        raise ValueError("skill_id is required")
+    if UUID_RE.match(skill_id):
+        return skill_id
+    data = graphql(
+        """query($orgId: ID!, $search: String) {
+            skills(orgId: $orgId, search: $search) { id slug name }
+        }""",
+        {"orgId": org_id, "search": skill_id},
+    )
+    skills: list[dict[str, Any]] = data.get("skills", [])
+    target = skill_id.lower()
+    for s in skills:
+        if s.get("slug", "").lower() == target or s.get("name", "").lower() == target:
+            return s["id"]
+    raise ValueError(f"Skill '{skill_id}' not found")
+
+
+def resolve_issue_id(issue_id: str) -> str:
+    """Accept either a UUID or a human identifier (e.g. 'AS-7') and return the UUID.
+
+    Raises ``ValueError`` if the identifier cannot be resolved.
+    """
+    if not issue_id:
+        raise ValueError("issue_id is required")
+    if UUID_RE.match(issue_id):
+        return issue_id
+    # Treat as a human identifier -- search for it
+    data = graphql(
+        """query($orgId: ID!, $search: String) {
+            issues(orgId: $orgId, search: $search) { id identifier }
+        }""",
+        {"orgId": org_id, "search": issue_id},
+    )
+    issues: list[dict[str, Any]] = data.get("issues", [])
+    target = issue_id.lower()
+    for i in issues:
+        if i.get("identifier", "").lower() == target:
+            return i["id"]
+    raise ValueError(f"Issue '{issue_id}' not found")
+
+
+def auth() -> dict[str, str]:
+    """Fetch identity via GraphQL ``{ me { ... } }``.
+
+    Session-start is detected server-side by the heartbeat in the
+    notification poll/stream endpoints, so no dedicated auth call is needed.
+    """
+    global member_id, org_id, member_timezone
+    resp = httpx.post(
+        f"{get_api_url()}/graphql",
+        headers=headers(),
+        json={"query": "{ me { id orgId displayName timezone } }"},
+        timeout=HTTP_TIMEOUT_S,
+    )
+    resp.raise_for_status()
+    gql: dict[str, Any] = resp.json()
+    me: dict[str, Any] | None = (gql.get("data") or {}).get("me")
+    if not me:
+        errors = gql.get("errors", [])
+        detail = errors[0]["message"] if errors else "unauthorized"
+        raise ValueError(f"GraphQL me query failed: {detail}")
+
+    member_id = me.get("id", "")
+    org_id = me.get("orgId", "")
+    member_timezone = me.get("timezone", "UTC")
+    display_name = me.get("displayName", "unknown")
+
+    return {"member_id": member_id, "org_id": org_id, "display_name": display_name}

agentslack_mcp-0.1.0/agentslack_mcp/constants.py

@@ -0,0 +1,90 @@
+"""Shared constants for the AgentSlack MCP server."""
+
+from __future__ import annotations
+
+import re
+
+# ---------------------------------------------------------------------------
+# Timeouts (seconds)
+# ---------------------------------------------------------------------------
+
+GRAPHQL_TIMEOUT_S: int = 15
+HTTP_TIMEOUT_S: int = 10
+NOTIFICATION_STREAM_TIMEOUT_S: int = 30
+NOTIFICATION_CLIENT_TIMEOUT_S: int = 35  # slightly > stream timeout
+
+# ---------------------------------------------------------------------------
+# Polling
+# ---------------------------------------------------------------------------
+
+POLL_INTERVAL_S: int = 3
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_API_URL: str = "http://localhost:8100"
+DEFAULT_MESSAGE_LIMIT: int = 30
+DEFAULT_NOTIFICATION_LIMIT: int = 20
+DEFAULT_RECAP_LIMIT: int = 5
+DEFAULT_GIF_LIMIT: int = 20
+MAX_GIF_LIMIT: int = 50
+
+# ---------------------------------------------------------------------------
+# GraphQL field fragments
+# ---------------------------------------------------------------------------
+
+MSG_FIELDS: str = (
+    "id content authorId createdAt "
+    "author { id displayName type } "
+    "replyCount latestReplyAt "
+    "threadParticipants { id displayName }"
+)
+
+DM_MSG_FIELDS: str = (
+    "id dmChannelId content authorId createdAt "
+    "author { id displayName type } "
+    "replyCount latestReplyAt"
+)
+
+ISSUE_FIELDS: str = (
+    "id identifier title description status priority "
+    "createdBy { id displayName } createdAt updatedAt completedAt "
+    "assignees { id displayName } "
+    "labels { id name color }"
+)
+
+CYCLE_FIELDS: str = (
+    "id orgId name description status startAt endAt "
+    "createdBy { id displayName } createdAt updatedAt"
+)
+
+PROJECT_FIELDS: str = (
+    "id orgId name description status startAt endAt "
+    "createdBy { id displayName } createdAt updatedAt"
+)
+
+# ---------------------------------------------------------------------------
+# Patterns
+# ---------------------------------------------------------------------------
+
+UUID_RE: re.Pattern[str] = re.compile(
+    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
+    re.IGNORECASE,
+)
+
+# ---------------------------------------------------------------------------
+# Feedback
+# ---------------------------------------------------------------------------
+
+FEEDBACK_CATEGORIES: frozenset[str] = frozenset(
+    {"missing_tool", "missing_feature", "bug", "ux", "other"}
+)
+
+# ---------------------------------------------------------------------------
+# Work status
+# ---------------------------------------------------------------------------
+
+WORK_STATUSES: frozenset[str] = frozenset(
+    {"available", "busy", "focus", "offline"}
+)

agentslack_mcp-0.1.0/agentslack_mcp/formatting.py

@@ -0,0 +1,88 @@
+"""Shared formatting helpers for converting GraphQL results to human-readable text."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def fmt_msg(msg: dict[str, Any]) -> str:
+    """Format a single message dict into a compact one-line string."""
+    author_obj = msg.get("author") or {}
+    author = author_obj.get("displayName", "unknown")
+    author_type = author_obj.get("type")
+    type_tag = f" [{author_type}]" if author_type else ""
+    ts = msg.get("createdAt", "?")
+    content = msg.get("content", "")
+    msg_id = msg.get("id", "")
+    id_tag = f" (id: {msg_id})" if msg_id else ""
+    reply_count: int = msg.get("replyCount") or 0
+    thread_info = ""
+    if reply_count:
+        participants: list[dict[str, Any]] = msg.get("threadParticipants", [])
+        names = ", ".join(p.get("displayName", "?") for p in participants)
+        thread_info = (
+            f" ({reply_count} replies — {names})" if names else f" ({reply_count} replies)"
+        )
+    return f"[{author}{type_tag} @ {ts}]{id_tag}{thread_info}: {content}"
+
+
+def fmt_issue(issue: dict[str, Any]) -> str:
+    """Format a single issue dict into a compact one-line string."""
+    assignees = ", ".join(
+        a.get("displayName", a.get("id", "?")) for a in issue.get("assignees", [])
+    ) or "unassigned"
+    labels = ", ".join(lbl.get("name", "?") for lbl in issue.get("labels", []))
+    label_str = f" [{labels}]" if labels else ""
+    issue_id = issue.get("id", "")
+    id_tag = f" (id: {issue_id})" if issue_id else ""
+    return (
+        f"- {issue.get('identifier', '?')}{id_tag}: {issue.get('title', '?')} "
+        f"({issue.get('status', '?')}/{issue.get('priority', '?')}) "
+        f"→ {assignees}{label_str}"
+    )
+
+
+def fmt_cycle(cycle: dict[str, Any]) -> str:
+    """Format a single cycle dict into a compact one-line string."""
+    status = cycle.get("status", "?")
+    start = cycle.get("startAt") or "unset"
+    end = cycle.get("endAt") or "unset"
+    creator = (cycle.get("createdBy") or {}).get("displayName", "?")
+    return (
+        f"- {cycle.get('name', '?')} (id: {cycle.get('id', '?')}) "
+        f"[{status}] {start} → {end} (by {creator})"
+    )
+
+
+def fmt_project(project: dict[str, Any]) -> str:
+    """Format a single project dict into a compact one-line string."""
+    status = project.get("status", "?")
+    start = project.get("startAt") or "unset"
+    end = project.get("endAt") or "unset"
+    creator = (project.get("createdBy") or {}).get("displayName", "?")
+    return (
+        f"- {project.get('name', '?')} (id: {project.get('id', '?')}) "
+        f"[{status}] {start} → {end} (by {creator})"
+    )
+
+
+def fmt_paginated_messages(
+    edges: list[dict[str, Any]],
+    page_info: dict[str, Any],
+    empty_label: str,
+) -> str:
+    """Format a paginated list of message edges with cursor info."""
+    if not edges:
+        return empty_label
+    lines = [f"{len(edges)} message(s):\n"]
+    for edge in edges:
+        lines.append(fmt_msg(edge["node"]))
+    if page_info.get("hasNextPage"):
+        lines.append(
+            f"\n(older messages available — use before_cursor: {page_info.get('endCursor')})"
+        )
+    if page_info.get("hasPreviousPage"):
+        lines.append(
+            f"\n(newer messages available — use after_cursor: {page_info.get('startCursor')})"
+        )
+    return "\n".join(lines)