linear-mcp-fast 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

linear_mcp_fast/reader.py

@@ -39,6 +39,13 @@ class CachedData:
     comments_by_issue: dict[str, list[str]] = field(default_factory=dict)
     projects: dict[str, dict[str, Any]] = field(default_factory=dict)
     issue_content: dict[str, str] = field(default_factory=dict)  # issueId -> description
+    labels: dict[str, dict[str, Any]] = field(default_factory=dict)
+    initiatives: dict[str, dict[str, Any]] = field(default_factory=dict)
+    cycles: dict[str, dict[str, Any]] = field(default_factory=dict)
+    documents: dict[str, dict[str, Any]] = field(default_factory=dict)
+    document_content: dict[str, dict[str, Any]] = field(default_factory=dict)
+    milestones: dict[str, dict[str, Any]] = field(default_factory=dict)
+    project_updates: dict[str, dict[str, Any]] = field(default_factory=dict)
     loaded_at: float = 0.0
 
     def is_expired(self) -> bool:
@@ -60,7 +67,6 @@ class LinearLocalReader:
         self._db_path = db_path
         self._blob_path = blob_path
         self._cache = CachedData()
-        self._stores: DetectedStores | None = None
 
     def _check_db_exists(self) -> None:
         """Verify the Linear database exists."""
@@ -75,17 +81,20 @@ class LinearLocalReader:
         self._check_db_exists()
         return ccl_chromium_indexeddb.WrappedIndexDB(self._db_path, self._blob_path)
 
-    def _find_linear_db(
+    def _find_all_linear_dbs(
         self, wrapper: ccl_chromium_indexeddb.WrappedIndexDB
-    ) -> ccl_chromium_indexeddb.WrappedDatabase:
-        """Find the main Linear database with data."""
+    ) -> list[ccl_chromium_indexeddb.WrappedDatabase]:
+        """Find all Linear databases with data."""
+        databases = []
         for db_id in wrapper.database_ids:
             if "linear_" in db_id.name and db_id.name != "linear_databases":
                 db = wrapper[db_id.name, db_id.origin]
                 # Skip empty databases
                 if list(db.object_store_names):
-                    return db
-        raise ValueError("Could not find Linear database in IndexedDB")
+                    databases.append(db)
+        if not databases:
+            raise ValueError("Could not find Linear database in IndexedDB")
+        return databases
 
     def _to_str(self, val: Any) -> str:
         """Convert value to string, handling bytes."""
@@ -207,19 +216,30 @@ class LinearLocalReader:
             pass
 
     def _reload_cache(self) -> None:
-        """Reload all data from the IndexedDB."""
+        """Reload all data from all Linear IndexedDB databases."""
         wrapper = self._get_wrapper()
-        db = self._find_linear_db(wrapper)
-
-        # Detect stores if not already done
-        if self._stores is None:
-            self._stores = detect_stores(db)
+        databases = self._find_all_linear_dbs(wrapper)
 
         cache = CachedData(loaded_at=time.time())
 
+        # Load from all databases
+        for db in databases:
+            stores = detect_stores(db)
+            self._load_from_db(db, stores, cache)
+
+        self._cache = cache
+
+    def _load_from_db(
+        self,
+        db: ccl_chromium_indexeddb.WrappedDatabase,
+        stores: DetectedStores,
+        cache: CachedData,
+    ) -> None:
+        """Load data from a single database into the cache."""
+
         # Load teams
-        if self._stores.teams:
-            for val in self._load_from_store(db, self._stores.teams):
+        if stores.teams:
+            for val in self._load_from_store(db, stores.teams):
                 cache.teams[val["id"]] = {
                     "id": val["id"],
                     "key": val.get("key"),
@@ -227,8 +247,8 @@ class LinearLocalReader:
                 }
 
         # Load users from all detected user stores
-        if self._stores.users:
-            for store_name in self._stores.users:
+        if stores.users:
+            for store_name in stores.users:
                 for val in self._load_from_store(db, store_name):
                     if val.get("id") not in cache.users:
                         cache.users[val["id"]] = {
@@ -239,8 +259,8 @@ class LinearLocalReader:
                         }
 
         # Load workflow states from all detected state stores
-        if self._stores.workflow_states:
-            for store_name in self._stores.workflow_states:
+        if stores.workflow_states:
+            for store_name in stores.workflow_states:
                 for val in self._load_from_store(db, store_name):
                     if val.get("id") not in cache.states:
                         cache.states[val["id"]] = {
@@ -253,8 +273,8 @@ class LinearLocalReader:
                         }
 
         # Load issues
-        if self._stores.issues:
-            for val in self._load_from_store(db, self._stores.issues):
+        if stores.issues:
+            for val in self._load_from_store(db, stores.issues):
                 team = cache.teams.get(val.get("teamId"), {})
                 team_key = team.get("key", "???")
                 identifier = f"{team_key}-{val.get('number')}"
@@ -283,8 +303,8 @@ class LinearLocalReader:
                 }
 
         # Load comments
-        if self._stores.comments:
-            for val in self._load_from_store(db, self._stores.comments):
+        if stores.comments:
+            for val in self._load_from_store(db, stores.comments):
                 comment_id = val.get("id")
                 issue_id = val.get("issueId")
                 if not comment_id or not issue_id:
@@ -304,8 +324,8 @@ class LinearLocalReader:
                 cache.comments_by_issue[issue_id].append(comment_id)
 
         # Load projects
-        if self._stores.projects:
-            for val in self._load_from_store(db, self._stores.projects):
+        if stores.projects:
+            for val in self._load_from_store(db, stores.projects):
                 cache.projects[val["id"]] = {
                     "id": val["id"],
                     "name": val.get("name"),
@@ -326,8 +346,8 @@ class LinearLocalReader:
                 }
 
         # Load issue content (Y.js encoded descriptions)
-        if self._stores.issue_content:
-            for val in self._load_from_store(db, self._stores.issue_content):
+        if stores.issue_content:
+            for val in self._load_from_store(db, stores.issue_content):
                 issue_id = val.get("issueId")
                 content_state = val.get("contentState")
                 if issue_id and content_state:
@@ -340,7 +360,101 @@ class LinearLocalReader:
             if issue_id in cache.issues and not cache.issues[issue_id].get("description"):
                 cache.issues[issue_id]["description"] = desc
 
-        self._cache = cache
+        # Load labels from all detected label stores
+        if stores.labels:
+            for store_name in stores.labels:
+                for val in self._load_from_store(db, store_name):
+                    if val.get("id") not in cache.labels:
+                        cache.labels[val["id"]] = {
+                            "id": val["id"],
+                            "name": val.get("name"),
+                            "color": val.get("color"),
+                            "isGroup": val.get("isGroup"),
+                            "parentId": val.get("parentId"),
+                            "teamId": val.get("teamId"),
+                        }
+
+        # Load initiatives
+        if stores.initiatives:
+            for val in self._load_from_store(db, stores.initiatives):
+                cache.initiatives[val["id"]] = {
+                    "id": val["id"],
+                    "name": val.get("name"),
+                    "slugId": val.get("slugId"),
+                    "color": val.get("color"),
+                    "status": val.get("status"),
+                    "ownerId": val.get("ownerId"),
+                    "teamIds": val.get("teamIds", []),
+                    "createdAt": val.get("createdAt"),
+                    "updatedAt": val.get("updatedAt"),
+                }
+
+        # Load cycles
+        if stores.cycles:
+            for val in self._load_from_store(db, stores.cycles):
+                cache.cycles[val["id"]] = {
+                    "id": val["id"],
+                    "number": val.get("number"),
+                    "teamId": val.get("teamId"),
+                    "startsAt": val.get("startsAt"),
+                    "endsAt": val.get("endsAt"),
+                    "completedAt": val.get("completedAt"),
+                    "currentProgress": val.get("currentProgress"),
+                }
+
+        # Load documents
+        if stores.documents:
+            for val in self._load_from_store(db, stores.documents):
+                doc_id = val.get("id")
+                # Documents may have multiple versions, keep the latest by updatedAt
+                existing = cache.documents.get(doc_id)
+                if existing and existing.get("updatedAt", "") >= val.get("updatedAt", ""):
+                    continue
+                cache.documents[doc_id] = {
+                    "id": doc_id,
+                    "title": val.get("title"),
+                    "slugId": val.get("slugId"),
+                    "projectId": val.get("projectId"),
+                    "creatorId": val.get("creatorId"),
+                    "createdAt": val.get("createdAt"),
+                    "updatedAt": val.get("updatedAt"),
+                }
+
+        # Load document content
+        if stores.document_content:
+            for val in self._load_from_store(db, stores.document_content):
+                content_id = val.get("documentContentId")
+                if content_id:
+                    cache.document_content[content_id] = {
+                        "id": val.get("id"),
+                        "documentContentId": content_id,
+                        "contentData": val.get("contentData"),
+                    }
+
+        # Load milestones
+        if stores.milestones:
+            for val in self._load_from_store(db, stores.milestones):
+                cache.milestones[val["id"]] = {
+                    "id": val["id"],
+                    "name": val.get("name"),
+                    "projectId": val.get("projectId"),
+                    "targetDate": val.get("targetDate"),
+                    "sortOrder": val.get("sortOrder"),
+                    "currentProgress": val.get("currentProgress"),
+                }
+
+        # Load project updates
+        if stores.project_updates:
+            for val in self._load_from_store(db, stores.project_updates):
+                cache.project_updates[val["id"]] = {
+                    "id": val["id"],
+                    "body": val.get("body"),
+                    "health": val.get("health"),
+                    "projectId": val.get("projectId"),
+                    "userId": val.get("userId"),
+                    "createdAt": val.get("createdAt"),
+                    "updatedAt": val.get("updatedAt"),
+                }
 
     def _ensure_cache(self) -> CachedData:
         """Ensure the cache is loaded and not expired."""
@@ -378,6 +492,36 @@ class LinearLocalReader:
         """Get all projects."""
         return self._ensure_cache().projects
 
+    @property
+    def labels(self) -> dict[str, dict[str, Any]]:
+        """Get all labels."""
+        return self._ensure_cache().labels
+
+    @property
+    def initiatives(self) -> dict[str, dict[str, Any]]:
+        """Get all initiatives."""
+        return self._ensure_cache().initiatives
+
+    @property
+    def cycles(self) -> dict[str, dict[str, Any]]:
+        """Get all cycles."""
+        return self._ensure_cache().cycles
+
+    @property
+    def documents(self) -> dict[str, dict[str, Any]]:
+        """Get all documents."""
+        return self._ensure_cache().documents
+
+    @property
+    def milestones(self) -> dict[str, dict[str, Any]]:
+        """Get all milestones."""
+        return self._ensure_cache().milestones
+
+    @property
+    def project_updates(self) -> dict[str, dict[str, Any]]:
+        """Get all project updates."""
+        return self._ensure_cache().project_updates
+
     def get_comments_for_issue(self, issue_id: str) -> list[dict[str, Any]]:
         """Get all comments for an issue, sorted by creation time."""
         cache = self._ensure_cache()
@@ -530,3 +674,49 @@ class LinearLocalReader:
             return ""
         project = self.projects.get(project_id, {})
         return project.get("name", "")
+
+    def get_label_name(self, label_id: str | None) -> str:
+        """Get label name from label ID."""
+        if not label_id:
+            return ""
+        label = self.labels.get(label_id, {})
+        return label.get("name", "")
+
+    def get_cycles_for_team(self, team_id: str) -> list[dict[str, Any]]:
+        """Get all cycles for a team, sorted by number descending."""
+        cycles = [c for c in self.cycles.values() if c.get("teamId") == team_id]
+        return sorted(cycles, key=lambda c: c.get("number", 0), reverse=True)
+
+    def get_documents_for_project(self, project_id: str) -> list[dict[str, Any]]:
+        """Get all documents for a project."""
+        return [d for d in self.documents.values() if d.get("projectId") == project_id]
+
+    def get_milestones_for_project(self, project_id: str) -> list[dict[str, Any]]:
+        """Get all milestones for a project, sorted by sortOrder."""
+        milestones = [m for m in self.milestones.values() if m.get("projectId") == project_id]
+        return sorted(milestones, key=lambda m: m.get("sortOrder", 0))
+
+    def get_updates_for_project(self, project_id: str) -> list[dict[str, Any]]:
+        """Get all updates for a project, sorted by creation time descending."""
+        updates = [u for u in self.project_updates.values() if u.get("projectId") == project_id]
+        return sorted(updates, key=lambda u: u.get("createdAt", ""), reverse=True)
+
+    def find_initiative(self, search: str) -> dict[str, Any] | None:
+        """Find an initiative by name or slugId (case-insensitive partial match)."""
+        search_lower = search.lower()
+        for initiative in self.initiatives.values():
+            name = self._to_str(initiative.get("name", ""))
+            slug_id = self._to_str(initiative.get("slugId", ""))
+            if search_lower in name.lower() or search_lower == slug_id.lower():
+                return initiative
+        return None
+
+    def find_document(self, search: str) -> dict[str, Any] | None:
+        """Find a document by title or slugId (case-insensitive partial match)."""
+        search_lower = search.lower()
+        for doc in self.documents.values():
+            title = self._to_str(doc.get("title", ""))
+            slug_id = self._to_str(doc.get("slugId", ""))
+            if search_lower in title.lower() or search_lower == slug_id.lower():
+                return doc
+        return None

linear_mcp_fast/server.py

@@ -150,66 +150,6 @@ def get_issue(identifier: str) -> dict[str, Any] | None:
     }
 
 
-@mcp.tool()
-def list_my_issues(
-    name: str,
-    state_type: str | None = None,
-    limit: int | None = None,
-) -> dict[str, Any]:
-    """
-    List 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: all)
-
-    Returns:
-        User info with their issues
-    """
-    reader = get_reader()
-
-    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] if limit else all_issues
-
-    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]]:
     """
@@ -456,6 +396,300 @@ def list_issue_statuses(team: str) -> list[dict[str, Any]]:
     return results
 
 
+@mcp.tool()
+def list_comments(issue_id: str) -> list[dict[str, Any]]:
+    """
+    List comments for a specific issue.
+
+    Args:
+        issue_id: Issue identifier (e.g., 'UK-55')
+
+    Returns:
+        List of comments with author info
+    """
+    reader = get_reader()
+    issue = reader.get_issue_by_identifier(issue_id)
+
+    if not issue:
+        return []
+
+    comments = reader.get_comments_for_issue(issue["id"])
+    results = []
+    for comment in comments:
+        user = reader.users.get(comment.get("userId", ""), {})
+        results.append({
+            "id": comment.get("id"),
+            "author": user.get("name", "Unknown"),
+            "body": comment.get("body", ""),
+            "createdAt": comment.get("createdAt"),
+            "updatedAt": comment.get("updatedAt"),
+        })
+
+    return results
+
+
+@mcp.tool()
+def list_issue_labels(team: str | None = None) -> list[dict[str, Any]]:
+    """
+    List available issue labels.
+
+    Args:
+        team: Optional team key to filter team-specific labels
+
+    Returns:
+        List of labels
+    """
+    reader = get_reader()
+
+    team_id = None
+    if team:
+        team_obj = reader.find_team(team)
+        if team_obj:
+            team_id = team_obj["id"]
+
+    results = []
+    for label in reader.labels.values():
+        # Include workspace labels (no teamId) and team-specific labels
+        if team_id and label.get("teamId") and label.get("teamId") != team_id:
+            continue
+        results.append({
+            "id": label.get("id"),
+            "name": label.get("name"),
+            "color": label.get("color"),
+            "isGroup": label.get("isGroup"),
+        })
+
+    results.sort(key=lambda x: x.get("name", "") or "")
+    return results
+
+
+@mcp.tool()
+def list_initiatives() -> list[dict[str, Any]]:
+    """
+    List all initiatives.
+
+    Returns:
+        List of initiatives
+    """
+    reader = get_reader()
+    results = []
+
+    for initiative in reader.initiatives.values():
+        results.append({
+            "id": initiative.get("id"),
+            "name": initiative.get("name"),
+            "slugId": initiative.get("slugId"),
+            "color": initiative.get("color"),
+            "status": initiative.get("status"),
+            "owner": reader.get_user_name(initiative.get("ownerId")),
+        })
+
+    results.sort(key=lambda x: x.get("name", "") or "")
+    return results
+
+
+@mcp.tool()
+def get_initiative(name: str) -> dict[str, Any] | None:
+    """
+    Get initiative details by name.
+
+    Args:
+        name: Initiative name (partial match)
+
+    Returns:
+        Initiative details or None if not found
+    """
+    reader = get_reader()
+    initiative = reader.find_initiative(name)
+
+    if not initiative:
+        return None
+
+    return {
+        "id": initiative.get("id"),
+        "name": initiative.get("name"),
+        "slugId": initiative.get("slugId"),
+        "color": initiative.get("color"),
+        "status": initiative.get("status"),
+        "owner": reader.get_user_name(initiative.get("ownerId")),
+        "teamIds": initiative.get("teamIds", []),
+        "createdAt": initiative.get("createdAt"),
+        "updatedAt": initiative.get("updatedAt"),
+    }
+
+
+@mcp.tool()
+def list_cycles(team: str) -> list[dict[str, Any]]:
+    """
+    List cycles for a team.
+
+    Args:
+        team: Team key (e.g., 'UK')
+
+    Returns:
+        List of cycles sorted by number (newest first)
+    """
+    reader = get_reader()
+
+    team_obj = reader.find_team(team)
+    if not team_obj:
+        return []
+
+    cycles = reader.get_cycles_for_team(team_obj["id"])
+    results = []
+    for cycle in cycles:
+        progress = cycle.get("currentProgress", {})
+        results.append({
+            "id": cycle.get("id"),
+            "number": cycle.get("number"),
+            "startsAt": cycle.get("startsAt"),
+            "endsAt": cycle.get("endsAt"),
+            "completedAt": cycle.get("completedAt"),
+            "progress": {
+                "completed": progress.get("completedIssueCount", 0),
+                "started": progress.get("startedIssueCount", 0),
+                "unstarted": progress.get("unstartedIssueCount", 0),
+                "total": progress.get("scopeCount", 0),
+            } if progress else None,
+        })
+
+    return results
+
+
+@mcp.tool()
+def list_documents(project: str | None = None) -> list[dict[str, Any]]:
+    """
+    List documents, optionally filtered by project.
+
+    Args:
+        project: Optional project name to filter
+
+    Returns:
+        List of documents
+    """
+    reader = get_reader()
+
+    project_id = None
+    if project:
+        project_obj = reader.find_project(project)
+        if project_obj:
+            project_id = project_obj["id"]
+        else:
+            return []
+
+    results = []
+    for doc in reader.documents.values():
+        if project_id and doc.get("projectId") != project_id:
+            continue
+        results.append({
+            "id": doc.get("id"),
+            "title": doc.get("title"),
+            "slugId": doc.get("slugId"),
+            "project": reader.get_project_name(doc.get("projectId")),
+            "createdAt": doc.get("createdAt"),
+            "updatedAt": doc.get("updatedAt"),
+        })
+
+    results.sort(key=lambda x: x.get("updatedAt", "") or "", reverse=True)
+    return results
+
+
+@mcp.tool()
+def get_document(name: str) -> dict[str, Any] | None:
+    """
+    Get document details by title.
+
+    Args:
+        name: Document title (partial match)
+
+    Returns:
+        Document details or None if not found
+    """
+    reader = get_reader()
+    doc = reader.find_document(name)
+
+    if not doc:
+        return None
+
+    return {
+        "id": doc.get("id"),
+        "title": doc.get("title"),
+        "slugId": doc.get("slugId"),
+        "project": reader.get_project_name(doc.get("projectId")),
+        "creator": reader.get_user_name(doc.get("creatorId")),
+        "createdAt": doc.get("createdAt"),
+        "updatedAt": doc.get("updatedAt"),
+        "url": f"https://linear.app/document/{doc.get('slugId')}",
+    }
+
+
+@mcp.tool()
+def list_milestones(project: str) -> list[dict[str, Any]]:
+    """
+    List milestones for a project.
+
+    Args:
+        project: Project name
+
+    Returns:
+        List of milestones sorted by order
+    """
+    reader = get_reader()
+
+    project_obj = reader.find_project(project)
+    if not project_obj:
+        return []
+
+    milestones = reader.get_milestones_for_project(project_obj["id"])
+    results = []
+    for milestone in milestones:
+        progress = milestone.get("currentProgress", {})
+        results.append({
+            "id": milestone.get("id"),
+            "name": milestone.get("name"),
+            "targetDate": milestone.get("targetDate"),
+            "progress": {
+                "completed": progress.get("completedIssueCount", 0),
+                "started": progress.get("startedIssueCount", 0),
+                "unstarted": progress.get("unstartedIssueCount", 0),
+                "total": progress.get("scopeCount", 0),
+            } if progress else None,
+        })
+
+    return results
+
+
+@mcp.tool()
+def list_project_updates(project: str) -> list[dict[str, Any]]:
+    """
+    List updates for a project.
+
+    Args:
+        project: Project name
+
+    Returns:
+        List of project updates sorted by date (newest first)
+    """
+    reader = get_reader()
+
+    project_obj = reader.find_project(project)
+    if not project_obj:
+        return []
+
+    updates = reader.get_updates_for_project(project_obj["id"])
+    results = []
+    for update in updates:
+        results.append({
+            "id": update.get("id"),
+            "body": update.get("body"),
+            "health": update.get("health"),
+            "author": reader.get_user_name(update.get("userId")),
+            "createdAt": update.get("createdAt"),
+        })
+
+    return results
+
+
 def main():
     """Run the MCP server."""
     mcp.run()

linear_mcp_fast/store_detector.py

@@ -22,6 +22,14 @@ class DetectedStores:
     comments: str | None = None
     projects: str | None = None
     issue_content: str | None = None  # Y.js encoded issue descriptions
+    labels: list[str] | None = None  # Issue labels (team + workspace)
+    initiatives: str | None = None
+    project_statuses: str | None = None
+    cycles: str | None = None
+    documents: str | None = None
+    document_content: str | None = None
+    milestones: str | None = None
+    project_updates: str | None = None
 
 
 def _is_issue_record(record: dict[str, Any]) -> bool:
@@ -75,6 +83,66 @@ def _is_issue_content_record(record: dict[str, Any]) -> bool:
     return required.issubset(record.keys())
 
 
+def _is_label_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a label."""
+    required = {"name", "color", "isGroup"}
+    return required.issubset(record.keys())
+
+
+def _is_initiative_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like an initiative."""
+    required = {"name", "ownerId", "slugId", "frequencyResolution"}
+    return required.issubset(record.keys())
+
+
+def _is_project_status_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a project status."""
+    if not {"name", "color", "position", "type", "indefinite"}.issubset(record.keys()):
+        return False
+    # Must not have teamId (that's workflow state)
+    return "teamId" not in record
+
+
+def _is_cycle_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a cycle."""
+    required = {"number", "teamId", "startsAt", "endsAt"}
+    return required.issubset(record.keys())
+
+
+def _is_document_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a document."""
+    required = {"title", "slugId", "projectId", "sortOrder"}
+    has_required = required.issubset(record.keys())
+    # Must not be an issue
+    not_issue = "number" not in record and "stateId" not in record
+    return has_required and not_issue
+
+
+def _is_document_content_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like document content."""
+    required = {"documentContentId", "contentData"}
+    return required.issubset(record.keys())
+
+
+def _is_milestone_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a project milestone."""
+    required = {"name", "projectId", "sortOrder"}
+    has_required = required.issubset(record.keys())
+    # May have targetDate, currentProgress
+    has_progress = "currentProgress" in record or "targetDate" in record
+    return has_required and has_progress
+
+
+def _is_project_update_record(record: dict[str, Any]) -> bool:
+    """Check if a record looks like a project update."""
+    # Has body and either projectId or health field
+    has_body = "body" in record
+    has_project = "projectId" in record or "health" in record
+    # Must not be a comment
+    not_comment = "issueId" not in record
+    return has_body and has_project and not_comment
+
+
 def detect_stores(db: ccl_chromium_indexeddb.WrappedDatabase) -> DetectedStores:
     """
     Detect object stores by sampling their first record.
@@ -85,7 +153,7 @@ def detect_stores(db: ccl_chromium_indexeddb.WrappedDatabase) -> DetectedStores:
     Returns:
         DetectedStores with detected store names for each entity type.
     """
-    result = DetectedStores(users=[], workflow_states=[])
+    result = DetectedStores(users=[], workflow_states=[], labels=[])
 
     for store_name in db.object_store_names:
         if store_name is None or store_name.startswith("_") or "_partial" in store_name:
@@ -118,6 +186,24 @@ def detect_stores(db: ccl_chromium_indexeddb.WrappedDatabase) -> DetectedStores:
                     result.projects = store_name
                 elif _is_issue_content_record(val) and result.issue_content is None:
                     result.issue_content = store_name
+                elif _is_label_record(val) and store_name not in (result.labels or []):
+                    if result.labels is None:
+                        result.labels = []
+                    result.labels.append(store_name)
+                elif _is_initiative_record(val) and result.initiatives is None:
+                    result.initiatives = store_name
+                elif _is_project_status_record(val) and result.project_statuses is None:
+                    result.project_statuses = store_name
+                elif _is_cycle_record(val) and result.cycles is None:
+                    result.cycles = store_name
+                elif _is_document_record(val) and result.documents is None:
+                    result.documents = store_name
+                elif _is_document_content_record(val) and result.document_content is None:
+                    result.document_content = store_name
+                elif _is_milestone_record(val) and result.milestones is None:
+                    result.milestones = store_name
+                elif _is_project_update_record(val) and result.project_updates is None:
+                    result.project_updates = store_name
 
                 break  # Only check first record
         except Exception:

{linear_mcp_fast-0.3.1.dist-info → linear_mcp_fast-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linear-mcp-fast
-Version: 0.3.1
+Version: 0.4.0
 Summary: Fast MCP server for Linear - reads from Linear.app's local cache on macOS
 Author: everything-chalna
 License-Expression: MIT
@@ -48,6 +48,7 @@ Linear.app (Electron) syncs all your data to a local IndexedDB. This MCP server
 - **Offline access** - Works without internet
 - **Faster iteration** - No rate limits, no latency
 - **Issue descriptions** - Extracts text from Y.js encoded content (v0.3.0+)
+- **All workspaces** - Reads from all Linear workspaces on your machine (v0.4.0+)
 
 ## Requirements
 
@@ -138,6 +139,15 @@ Tools mirror the official Linear MCP for easy switching:
 | `list_users` | List all users |
 | `get_user` | Get user details |
 | `list_issue_statuses` | List workflow states for a team |
+| `list_comments` | List comments for an issue |
+| `list_issue_labels` | List available issue labels |
+| `list_initiatives` | List all initiatives |
+| `get_initiative` | Get initiative details |
+| `list_cycles` | List cycles for a team |
+| `list_documents` | List documents (optionally by project) |
+| `get_document` | Get document details |
+| `list_milestones` | List milestones for a project |
+| `list_project_updates` | List updates for a project |
 
 For writes (create issue, add comment, update status), use the official Linear MCP.
 

{linear_mcp_fast-0.3.1.dist-info → linear_mcp_fast-0.4.0.dist-info}/RECORD

@@ -23,17 +23,17 @@ ccl_simplesnappy/__init__.py,sha256=OqArK0MfdVl2oMw1MwpWSYWWVLFT-VLIWnEXXCsacJo,
 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=wa2FtrGVq92aa98mVdQmxb8OgemaS2Az6zclVgicEo0,20382
-linear_mcp_fast/server.py,sha256=Ha9kCLb_-V7c0HTSz3navb9EEWNmsTh320vRhI8ppmw,12757
-linear_mcp_fast/store_detector.py,sha256=BkwKelUlOCkn-e2pDtP5KcITb6juij7zmBOUOnNHc8Y,4585
+linear_mcp_fast/reader.py,sha256=gLNy8VBL5NNjvRJvvlcoUkHPaIf_X_rxASm_sR62WyU,28641
+linear_mcp_fast/server.py,sha256=QUXpIJGGk8oatN5jKMImcN_zfvYi_okr4m5mw_8iJ5U,18801
+linear_mcp_fast/store_detector.py,sha256=nUaX6HGSS_L4lqXHYo6aw6979O_7qR1sAHP_KybWLZg,8375
 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.3.1.dist-info/METADATA,sha256=kcsnPWx6VVZ6NAmOJu1oRPccW0FHJRO1t0TziS3M6tU,5295
-linear_mcp_fast-0.3.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-linear_mcp_fast-0.3.1.dist-info/entry_points.txt,sha256=Aa98tAkWz_08mS_SRyfyx0k3PuMBQoMygT88HCKMyWk,57
-linear_mcp_fast-0.3.1.dist-info/top_level.txt,sha256=j-O2BoBpFBpGyTl2V1cp0ZjxZAQwpkweeNxG4BcQ7io,73
-linear_mcp_fast-0.3.1.dist-info/RECORD,,
+linear_mcp_fast-0.4.0.dist-info/METADATA,sha256=UE51XV2JDYjhpqtb07leypxr1UUtPGxd4mv7lDQ6WSc,5829
+linear_mcp_fast-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+linear_mcp_fast-0.4.0.dist-info/entry_points.txt,sha256=Aa98tAkWz_08mS_SRyfyx0k3PuMBQoMygT88HCKMyWk,57
+linear_mcp_fast-0.4.0.dist-info/top_level.txt,sha256=j-O2BoBpFBpGyTl2V1cp0ZjxZAQwpkweeNxG4BcQ7io,73
+linear_mcp_fast-0.4.0.dist-info/RECORD,,