linear-mcp-fast 0.1.0__py3-none-any.whl

linear_mcp_fast/server.py

@@ -0,0 +1,367 @@
+"""
+MCP Server for Linear Local Cache.
+
+Provides fast, read-only access to Linear data from local cache.
+For write operations, use the official Linear MCP server.
+"""
+
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from .reader import LinearLocalReader
+
+mcp = FastMCP(
+    "Linear Local Cache",
+    instructions=(
+        "Fast, read-only access to Linear data from the local Linear.app cache on macOS. "
+        "Data freshness depends on Linear.app's last sync. "
+        "For write operations (comments, updates), use the official Linear MCP server."
+    ),
+)
+
+_reader: LinearLocalReader | None = None
+
+
+def get_reader() -> LinearLocalReader:
+    """Get or create the LinearLocalReader instance."""
+    global _reader
+    if _reader is None:
+        _reader = LinearLocalReader()
+    return _reader
+
+
+def _parse_datetime(dt_value: Any) -> float | None:
+    """Parse a datetime value to Unix timestamp."""
+    if dt_value is None:
+        return None
+    if isinstance(dt_value, (int, float)):
+        if dt_value > 1e12:
+            return dt_value / 1000
+        return dt_value
+    if isinstance(dt_value, str):
+        from datetime import datetime
+        try:
+            dt_str = dt_value.replace("Z", "+00:00")
+            dt = datetime.fromisoformat(dt_str)
+            return dt.timestamp()
+        except ValueError:
+            return None
+    return None
+
+
+@mcp.tool()
+def list_issues(
+    assignee: str | None = None,
+    team: str | None = None,
+    state_type: str | None = None,
+    priority: int | None = None,
+    limit: int = 50,
+) -> dict[str, Any]:
+    """
+    List issues from local cache with optional filters.
+
+    Args:
+        assignee: Filter by assignee name (partial match)
+        team: Filter by team key (e.g., 'UK')
+        state_type: Filter by state type (started, unstarted, completed, canceled, backlog)
+        priority: Filter by priority (1=Urgent, 2=High, 3=Medium, 4=Low)
+        limit: Maximum number of issues (default 50, max 100)
+
+    Returns:
+        Dictionary with issues array and totalCount
+    """
+    reader = get_reader()
+    limit = min(limit, 100)
+
+    assignee_id = None
+    if assignee:
+        user = reader.find_user(assignee)
+        if user:
+            assignee_id = user["id"]
+        else:
+            return {"issues": [], "totalCount": 0}
+
+    team_id = None
+    if team:
+        team_obj = reader.find_team(team)
+        if team_obj:
+            team_id = team_obj["id"]
+        else:
+            return {"issues": [], "totalCount": 0}
+
+    all_issues = sorted(
+        reader.issues.values(),
+        key=lambda x: (x.get("priority") or 4, x.get("updatedAt") or ""),
+    )
+
+    filtered = []
+    for issue in all_issues:
+        if assignee_id and issue.get("assigneeId") != assignee_id:
+            continue
+        if team_id and issue.get("teamId") != team_id:
+            continue
+        if state_type and reader.get_state_type(issue.get("stateId", "")) != state_type:
+            continue
+        if priority is not None and issue.get("priority") != priority:
+            continue
+        filtered.append(issue)
+
+    total_count = len(filtered)
+    page = filtered[:limit]
+
+    results = []
+    for issue in page:
+        results.append({
+            "identifier": issue.get("identifier"),
+            "title": issue.get("title"),
+            "priority": issue.get("priority"),
+            "state": reader.get_state_name(issue.get("stateId", "")),
+            "stateType": reader.get_state_type(issue.get("stateId", "")),
+            "assignee": reader.get_user_name(issue.get("assigneeId")),
+            "dueDate": issue.get("dueDate"),
+        })
+
+    return {"issues": results, "totalCount": total_count}
+
+
+@mcp.tool()
+def get_issue(identifier: str) -> dict[str, Any] | None:
+    """
+    Get issue details by identifier (e.g., 'UK-55').
+
+    Args:
+        identifier: Issue identifier like 'UK-55'
+
+    Returns:
+        Issue details with comments, or None if not found
+    """
+    reader = get_reader()
+    issue = reader.get_issue_by_identifier(identifier)
+
+    if not issue:
+        return None
+
+    comments = reader.get_comments_for_issue(issue["id"])
+    enriched_comments = []
+    for comment in comments:
+        user = reader.users.get(comment.get("userId", ""), {})
+        enriched_comments.append({
+            "author": user.get("name", "Unknown"),
+            "body": comment.get("body", ""),
+            "createdAt": comment.get("createdAt"),
+        })
+
+    return {
+        "identifier": issue.get("identifier"),
+        "title": issue.get("title"),
+        "description": issue.get("description"),
+        "priority": issue.get("priority"),
+        "estimate": issue.get("estimate"),
+        "state": reader.get_state_name(issue.get("stateId", "")),
+        "stateType": reader.get_state_type(issue.get("stateId", "")),
+        "assignee": reader.get_user_name(issue.get("assigneeId")),
+        "project": reader.get_project_name(issue.get("projectId")),
+        "dueDate": issue.get("dueDate"),
+        "createdAt": issue.get("createdAt"),
+        "updatedAt": issue.get("updatedAt"),
+        "comments": enriched_comments,
+        "url": f"https://linear.app/issue/{issue.get('identifier')}",
+    }
+
+
+@mcp.tool()
+def search_issues(query: str, limit: int = 20) -> dict[str, Any]:
+    """
+    Search issues by title.
+
+    Args:
+        query: Search query (case-insensitive)
+        limit: Maximum results (default 20, max 100)
+
+    Returns:
+        Dictionary with matching issues
+    """
+    reader = get_reader()
+    limit = min(limit, 100)
+    query_lower = query.lower()
+
+    all_issues = sorted(
+        reader.issues.values(),
+        key=lambda x: (x.get("priority") or 4, x.get("id", "")),
+    )
+
+    filtered = []
+    for issue in all_issues:
+        title = issue.get("title", "") or ""
+        identifier = issue.get("identifier", "") or ""
+        if query_lower in title.lower() or query_lower in identifier.lower():
+            filtered.append(issue)
+
+    match_count = len(filtered)
+    page = filtered[:limit]
+
+    results = []
+    for issue in page:
+        results.append({
+            "identifier": issue.get("identifier"),
+            "title": issue.get("title"),
+            "state": reader.get_state_name(issue.get("stateId", "")),
+            "stateType": reader.get_state_type(issue.get("stateId", "")),
+        })
+
+    return {"issues": results, "matchCount": match_count}
+
+
+@mcp.tool()
+def get_my_issues(
+    name: str,
+    state_type: str | None = None,
+    limit: int = 30,
+) -> dict[str, Any]:
+    """
+    Get issues assigned to a user.
+
+    Args:
+        name: User name to search for
+        state_type: Optional filter (started, unstarted, completed, canceled, backlog)
+        limit: Maximum issues (default 30, max 100)
+
+    Returns:
+        User info with their issues
+    """
+    reader = get_reader()
+    limit = min(limit, 100)
+
+    user = reader.find_user(name)
+    if not user:
+        return {"error": f"User '{name}' not found"}
+
+    all_issues = sorted(
+        reader.get_issues_for_user(user["id"]),
+        key=lambda x: (x.get("priority") or 4, x.get("id", "")),
+    )
+
+    counts_by_state: dict[str, int] = {}
+    for issue in all_issues:
+        issue_state_type = reader.get_state_type(issue.get("stateId", ""))
+        counts_by_state[issue_state_type] = counts_by_state.get(issue_state_type, 0) + 1
+
+    if state_type:
+        all_issues = [
+            i for i in all_issues
+            if reader.get_state_type(i.get("stateId", "")) == state_type
+        ]
+
+    page = all_issues[:limit]
+
+    results = []
+    for issue in page:
+        results.append({
+            "identifier": issue.get("identifier"),
+            "title": issue.get("title"),
+            "priority": issue.get("priority"),
+            "state": reader.get_state_name(issue.get("stateId", "")),
+            "stateType": reader.get_state_type(issue.get("stateId", "")),
+            "dueDate": issue.get("dueDate"),
+        })
+
+    return {
+        "user": {"name": user.get("name"), "email": user.get("email")},
+        "totalIssues": sum(counts_by_state.values()),
+        "countsByState": counts_by_state,
+        "issues": results,
+    }
+
+
+@mcp.tool()
+def list_teams() -> list[dict[str, Any]]:
+    """
+    List all teams with issue counts.
+
+    Returns:
+        List of teams
+    """
+    reader = get_reader()
+    results = []
+
+    for team in reader.teams.values():
+        issue_count = sum(
+            1 for i in reader.issues.values() if i.get("teamId") == team["id"]
+        )
+        results.append({
+            "key": team.get("key"),
+            "name": team.get("name"),
+            "issueCount": issue_count,
+        })
+
+    results.sort(key=lambda x: x.get("key", ""))
+    return results
+
+
+@mcp.tool()
+def list_projects(team: str | None = None) -> list[dict[str, Any]]:
+    """
+    List all projects with issue counts.
+
+    Args:
+        team: Optional team key to filter
+
+    Returns:
+        List of projects
+    """
+    reader = get_reader()
+
+    team_id = None
+    if team:
+        team_obj = reader.find_team(team)
+        if team_obj:
+            team_id = team_obj["id"]
+        else:
+            return []
+
+    results = []
+    for project in reader.projects.values():
+        if team_id and team_id not in project.get("teamIds", []):
+            continue
+
+        issue_count = sum(
+            1 for i in reader.issues.values() if i.get("projectId") == project["id"]
+        )
+
+        results.append({
+            "name": project.get("name"),
+            "state": project.get("state"),
+            "issueCount": issue_count,
+            "startDate": project.get("startDate"),
+            "targetDate": project.get("targetDate"),
+        })
+
+    results.sort(key=lambda x: x.get("name", "") or "")
+    return results
+
+
+@mcp.tool()
+def get_summary() -> dict[str, Any]:
+    """
+    Get a summary of local cache data.
+
+    Returns:
+        Counts of teams, users, issues, projects, comments
+    """
+    reader = get_reader()
+    summary = reader.get_summary()
+
+    # Add state breakdown
+    state_counts: dict[str, int] = {}
+    for issue in reader.issues.values():
+        state_type = reader.get_state_type(issue.get("stateId", ""))
+        state_counts[state_type] = state_counts.get(state_type, 0) + 1
+
+    summary["issuesByState"] = state_counts
+    return summary
+
+
+def main():
+    """Run the MCP server."""
+    mcp.run()

linear_mcp_fast/store_detector.py

@@ -0,0 +1,117 @@
+"""
+Auto-detect Linear IndexedDB object store hashes by sampling records.
+
+Linear uses hash-based object store names that may change between versions.
+This module detects stores by examining the structure of their records.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+from ccl_chromium_reader import ccl_chromium_indexeddb  # type: ignore
+
+
+@dataclass
+class DetectedStores:
+    """Container for detected object store names."""
+
+    issues: str | None = None
+    teams: str | None = None
+    users: list[str] | None = None
+    workflow_states: list[str] | None = None
+    comments: str | None = None
+    projects: str | None = None
+
+
+def _is_issue_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like an issue."""
+    required = {"number", "teamId", "stateId", "title"}
+    return required.issubset(record.keys())
+
+
+def _is_user_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a user."""
+    required = {"name", "displayName", "email"}
+    has_required = required.issubset(record.keys())
+    has_avatar = "avatarUrl" in record or "avatar" in record
+    return has_required and has_avatar
+
+
+def _is_team_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a team."""
+    if not {"key", "name"}.issubset(record.keys()):
+        return False
+    key = record.get("key")
+    if not isinstance(key, str):
+        return False
+    return key.isupper() and key.isalpha() and len(key) <= 10
+
+
+def _is_workflow_state_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a workflow state."""
+    if not {"name", "type", "color"}.issubset(record.keys()):
+        return False
+    state_type = record.get("type")
+    valid_types = {"started", "unstarted", "completed", "canceled", "backlog"}
+    return state_type in valid_types
+
+
+def _is_comment_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a comment."""
+    required = {"issueId", "userId", "bodyData", "createdAt"}
+    return required.issubset(record.keys())
+
+
+def _is_project_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a project."""
+    required = {"name", "description", "teamIds", "startDate", "targetDate", "statusId"}
+    return required.issubset(record.keys())
+
+
+def detect_stores(db: ccl_chromium_indexeddb.WrappedDatabase) -> DetectedStores:
+    """
+    Detect object stores by sampling their first record.
+
+    Args:
+        db: The wrapped IndexedDB database to scan.
+
+    Returns:
+        DetectedStores with detected store names for each entity type.
+    """
+    result = DetectedStores(users=[], workflow_states=[])
+
+    for store_name in db.object_store_names:
+        if store_name is None or store_name.startswith("_") or "_partial" in store_name:
+            continue
+
+        try:
+            store = db[store_name]
+            for record in store.iterate_records():
+                val = record.value
+                if not isinstance(val, dict):
+                    break
+
+                if _is_issue_record(val) and result.issues is None:
+                    result.issues = store_name
+                elif _is_team_record(val) and result.teams is None:
+                    result.teams = store_name
+                elif _is_user_record(val) and store_name not in (result.users or []):
+                    if result.users is None:
+                        result.users = []
+                    result.users.append(store_name)
+                elif _is_workflow_state_record(val) and store_name not in (
+                    result.workflow_states or []
+                ):
+                    if result.workflow_states is None:
+                        result.workflow_states = []
+                    result.workflow_states.append(store_name)
+                elif _is_comment_record(val) and result.comments is None:
+                    result.comments = store_name
+                elif _is_project_record(val) and result.projects is None:
+                    result.projects = store_name
+
+                break  # Only check first record
+        except Exception:
+            continue
+
+    return result

linear_mcp_fast-0.1.0.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: linear-mcp-fast
+Version: 0.1.0
+Summary: Fast MCP server for Linear - reads from Linear.app's local cache on macOS
+Author: everything-chalna
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/everything-chalna/linear-mcp-fast
+Project-URL: Repository, https://github.com/everything-chalna/linear-mcp-fast
+Project-URL: Issues, https://github.com/everything-chalna/linear-mcp-fast/issues
+Keywords: linear,mcp,cache,indexeddb,macos
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: brotli>=1.0.0
+
+# linear-mcp-fast
+
+Fast, read-only MCP server for Linear that reads from Linear.app's local cache on macOS.
+
+**Why?**
+- **Instant**: No API calls, reads directly from local IndexedDB cache
+- **Offline**: Works without internet
+- **Lower context**: Smaller responses for AI assistants
+
+**Use with**: Official Linear MCP for write operations (comments, updates).
+
+## Installation
+
+```bash
+pip install linear-mcp-fast
+# or
+uv pip install linear-mcp-fast
+```
+
+## Setup
+
+### Claude Code
+
+```bash
+# 1. Add linear-mcp-fast (reads from local cache)
+claude mcp add linear-fast -- uvx linear-mcp-fast
+
+# 2. Add official Linear MCP (for writes)
+claude mcp add --transport http linear https://mcp.linear.app/mcp
+```
+
+Now you have:
+- `linear-fast` → Fast reads from local cache
+- `linear` → Writes (comments, updates)
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "linear-fast": {
+      "command": "uvx",
+      "args": ["linear-mcp-fast"]
+    },
+    "linear": {
+      "command": "npx",
+      "args": ["-y", "mcp-remote", "https://mcp.linear.app/mcp"]
+    }
+  }
+}
+```
+
+### Cursor / VS Code
+
+```json
+{
+  "mcpServers": {
+    "linear-fast": {
+      "command": "uvx",
+      "args": ["linear-mcp-fast"]
+    },
+    "linear": {
+      "command": "npx",
+      "args": ["-y", "mcp-remote", "https://mcp.linear.app/mcp"]
+    }
+  }
+}
+```
+
+---
+
+## Prerequisites
+
+- **macOS** (Linear.app stores cache in `~/Library/Application Support/Linear/`)
+- **Linear.app** installed and opened at least once
+
+---
+
+## Available Tools
+
+### Reading (linear-fast)
+
+| Tool | Description |
+|------|-------------|
+| `list_issues` | List issues with filters (assignee, team, state, priority) |
+| `get_issue` | Get issue details with comments |
+| `search_issues` | Search issues by title |
+| `get_my_issues` | Get issues assigned to a user |
+| `list_teams` | List all teams |
+| `list_projects` | List all projects |
+| `get_summary` | Get cache summary |
+
+### Writing (official Linear MCP)
+
+Use the official Linear MCP (`linear`) for:
+- Creating/updating issues
+- Adding comments
+- Changing status
+
+---
+
+## Troubleshooting
+
+### "Linear database not found"
+
+Linear.app needs to be installed and opened at least once:
+```bash
+ls ~/Library/Application\ Support/Linear/IndexedDB/
+```
+
+### Data seems stale
+
+Local cache is updated when Linear.app syncs. Open Linear.app to refresh.
+
+---
+
+## How It Works
+
+```
+Linear.app (Electron)
+    ↓ syncs to
+IndexedDB (LevelDB format)
+~/Library/Application Support/Linear/IndexedDB/...
+    ↓ read by
+linear-mcp-fast
+    ↓ provides
+Fast read-only access to issues, users, teams, comments
+```
+
+---
+
+## License
+
+MIT

linear_mcp_fast-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+ccl_chromium_reader/__init__.py,sha256=ktLJfrcRmDRw8kc81l71lHYNjGuqXCkzBMYEvRhQLP4,93
+ccl_chromium_reader/ccl_chromium_cache.py,sha256=JE5DnhZTJ8QPuaTSJykzNtm7SrKV92d-hJR3ZEkaYQ0,49588
+ccl_chromium_reader/ccl_chromium_filesystem.py,sha256=R4bBkDvtbw0Y6lZjg98bVfJaRpvD9Ckvl6gThVBViT8,12949
+ccl_chromium_reader/ccl_chromium_history.py,sha256=ULexw7SV8vR0Mwx-ZMcstB-eSDLcrUSUkqji1tMS2CQ,11910
+ccl_chromium_reader/ccl_chromium_indexeddb.py,sha256=arHjNf6fWgYwmK7IKOY59Dm3Z9T-X2t1TiIY3bE-Xyk,44498
+ccl_chromium_reader/ccl_chromium_localstorage.py,sha256=DHr-KSxDJa49l4DjraoFSGDUsFVK1wpp2hB6EShx4ug,20269
+ccl_chromium_reader/ccl_chromium_notifications.py,sha256=9pDKdMZFNTXfSN0lhwcPUd3XTS9ulwAjqWcujjJZiIU,10876
+ccl_chromium_reader/ccl_chromium_profile_folder.py,sha256=psN3m40iha3W8Fn-Sb8V74HE4_hrcGKNyKJmZdtCV58,29076
+ccl_chromium_reader/ccl_chromium_sessionstorage.py,sha256=4hHogY7pAMnzbTZ3Ikv42jd42lBDyjWp2UjTSp2nbCo,15848
+ccl_chromium_reader/ccl_chromium_snss2.py,sha256=8rWyncs4l_l3dB-TaNPPIWjIxc3yWvBHwgkV0sm758s,12336
+ccl_chromium_reader/ccl_shared_proto_db_downloads.py,sha256=9cEGFhlwXwHhtgXUt3tJ2IxNPgDPBwGRgdpInuyTfNI,8413
+ccl_chromium_reader/common.py,sha256=ciCeGUUyXzz0IQ0nPFirEHVJB9uat4nnGp123Mdq9eE,618
+ccl_chromium_reader/download_common.py,sha256=u4jFOdDqfBqh9t8TV5iiGoy3P2lJRhoUx60V5eLSC40,2977
+ccl_chromium_reader/profile_folder_protocols.py,sha256=1oBpowQraWJ_ckTX4xrjRkNPmZEX8bhad6Yrxg8kqP8,12306
+ccl_chromium_reader/serialization_formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ccl_chromium_reader/serialization_formats/ccl_blink_value_deserializer.py,sha256=jqHf9I4fwXam1DMS5iVcbX_G-m-TQcaC_CwhyNylQJM,18647
+ccl_chromium_reader/serialization_formats/ccl_easy_chromium_pickle.py,sha256=YQ5Dofla2OSR-3p32FO1rGTXn8qD7942lxU6VE_-PRE,4388
+ccl_chromium_reader/serialization_formats/ccl_protobuff.py,sha256=3OJUcy2ZwR1qU8NrjEyDItt5uqMpo0TM0ixWqFNbb2s,8990
+ccl_chromium_reader/serialization_formats/ccl_v8_value_deserializer.py,sha256=c_bJHGVzqKs1X0dw0EwojNmoh5d1THI1OiKzgu-wLWY,22979
+ccl_chromium_reader/storage_formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ccl_chromium_reader/storage_formats/ccl_leveldb.py,sha256=KEM6hQryZZrWZ6KafaHYX69QAMT07BuCvfBIpkAeFsA,22989
+ccl_simplesnappy/__init__.py,sha256=OqArK0MfdVl2oMw1MwpWSYWWVLFT-VLIWnEXXCsacJo,59
+ccl_simplesnappy/ccl_simplesnappy.py,sha256=dLv1wejr2vCa2b_ZinozXVfcSsZIzJrt5ZkyxA3cQXA,10461
+linear_mcp_fast/__init__.py,sha256=T-ioPzoZXC3a_zLilZuDBCXUn8nDjvITS7svk7BwWmY,138
+linear_mcp_fast/__main__.py,sha256=2wkhXADcE2oGdtEpGrIvvEe9YGKjpwnJ3DBWghkVQKk,124
+linear_mcp_fast/reader.py,sha256=lf-bHccLSzmP0Ez4UeRLLYoYvVwlZOByWnfcUTtuuV0,16249
+linear_mcp_fast/server.py,sha256=cz-kSNy4y4xSRJRx_x9IyNl7TlwU9U3rA0pH1ro3QWs,10389
+linear_mcp_fast/store_detector.py,sha256=5cnTwS-LPsgS9NivNxKa3bPv4mwAnZsi40-kXszejMI,4142
+tools_and_utilities/Chromium_dump_local_storage.py,sha256=gG-pKFFk6lo332LQy2JvInlQh9Zldm5zAsuibb-dBkQ,4337
+tools_and_utilities/Chromium_dump_session_storage.py,sha256=17BKFWioo6fPwYkH58QycJCA-z85RtWMBXsJ_29hHQs,3484
+tools_and_utilities/benchmark.py,sha256=fyD5U6yI7Y0TkyhYtvvaHyk9Y2jJe2yxYWoFPQWypzA,1089
+tools_and_utilities/ccl_chrome_audit.py,sha256=irGyYJae0apZDZCn23jMKmY3tYQgWyZEL8vdUBcHLZk,24695
+tools_and_utilities/dump_indexeddb_details.py,sha256=ipNWLKPQoSNhCtPHKWvMWpKu8FhCnvc4Rciyx-90boI,2298
+tools_and_utilities/dump_leveldb.py,sha256=hj7QnOHG64KK2fKsZ9qQOVqUUmHUtxUZqPYl4EZJO9U,1882
+linear_mcp_fast-0.1.0.dist-info/METADATA,sha256=0aRAuDTEJ6TQDu1tEkJQAtCkXbEftJ1CLCukOGdg8p8,3691
+linear_mcp_fast-0.1.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+linear_mcp_fast-0.1.0.dist-info/entry_points.txt,sha256=Aa98tAkWz_08mS_SRyfyx0k3PuMBQoMygT88HCKMyWk,57
+linear_mcp_fast-0.1.0.dist-info/top_level.txt,sha256=j-O2BoBpFBpGyTl2V1cp0ZjxZAQwpkweeNxG4BcQ7io,73
+linear_mcp_fast-0.1.0.dist-info/RECORD,,

linear_mcp_fast-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

linear_mcp_fast-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+linear-mcp-fast = linear_mcp_fast:main

linear_mcp_fast-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+ccl_chromium_reader
+ccl_simplesnappy
+linear_mcp_fast
+tools_and_utilities