patch of lots a goodies · round #0 · pull #1 · zzstoatzz.io/tangled-mcp

+137

NEXT_STEPS.md

···

       1
       1
       +
       # next steps

     

       2
       2
       +
       

     

       3
       3
       +
       ## critical fixes

     

       4
       4
       +
       

     

       5
       5
       +
       ### 1. label validation must fail loudly

     

       6
       6
       +
       

     

       7
       7
       +
       **problem:** when users specify labels that don't exist in the repo's subscribed label definitions, they're silently ignored. no error, no warning, just nothing happens.

     

       8
       8
       +
       

     

       9
       9
       +
       **current behavior:**

     

       10
       10
       +
       ```python

     

       11
       11
       +
       create_repo_issue(repo="owner/repo", labels=["demo", "nonexistent"])

     

       12
       12
       +
       # -> creates issue with NO labels, returns success

     

       13
       13
       +
       ```

     

       14
       14
       +
       

     

       15
       15
       +
       **what should happen:**

     

       16
       16
       +
       ```python

     

       17
       17
       +
       create_repo_issue(repo="owner/repo", labels=["demo", "nonexistent"])

     

       18
       18
       +
       # -> raises ValueError:

     

       19
       19
       +
       #    "invalid labels: ['demo', 'nonexistent']

     

       20
       20
       +
       #     available labels for this repo: ['wontfix', 'duplicate', 'good-first-issue', ...]"

     

       21
       21
       +
       ```

     

       22
       22
       +
       

     

       23
       23
       +
       **fix locations:**

     

       24
       24
       +
       - `src/tangled_mcp/_tangled/_issues.py:_apply_labels()` - validate before applying

     

       25
       25
       +
       - add `validate_labels()` helper that checks against repo's subscribed labels

     

       26
       26
       +
       - fail fast with actionable error message listing available labels

     

       27
       27
       +
       

     

       28
       28
       +
       ### 2. list_repo_issues should include label information

     

       29
       29
       +
       

     

       30
       30
       +
       **problem:** `list_repo_issues` returns issues but doesn't include their labels. labels are stored separately in `sh.tangled.label.op` records and need to be fetched and correlated.

     

       31
       31
       +
       

     

       32
       32
       +
       **impact:** users can't see what labels an issue has without manually querying label ops or checking the UI.

     

       33
       33
       +
       

     

       34
       34
       +
       **fix:**

     

       35
       35
       +
       - add `labels: list[str]` field to `IssueInfo` model

     

       36
       36
       +
       - in `list_repo_issues`, fetch label ops and correlate with issues

     

       37
       37
       +
       - return label names (not URIs) for better UX

     

       38
       38
       +
       

     

       39
       39
       +
       ### 3. fix pydantic field warning

     

       40
       40
       +
       

     

       41
       41
       +
       **warning:**

     

       42
       42
       +
       ```

     

       43
       43
       +
       UnsupportedFieldAttributeWarning: The 'default' attribute with value None was provided

     

       44
       44
       +
       to the `Field()` function, which has no effect in the context it was used.

     

       45
       45
       +
       ```

     

       46
       46
       +
       

     

       47
       47
       +
       **likely cause:** somewhere we're using `Field(default=None)` in an `Annotated` type or union context where it doesn't make sense.

     

       48
       48
       +
       

     

       49
       49
       +
       **fix:** audit all `Field()` uses and remove invalid `default=None` declarations.

     

       50
       50
       +
       

     

       51
       51
       +
       ## enhancements

     

       52
       52
       +
       

     

       53
       53
       +
       ### 4. better error messages for repo resolution failures

     

       54
       54
       +
       

     

       55
       55
       +
       when a repo doesn't exist or handle can't be resolved, give users clear next steps:

     

       56
       56
       +
       - is the repo name spelled correctly?

     

       57
       57
       +
       - does the repo exist on tangled.org?

     

       58
       58
       +
       - do you have access to it?

     

       59
       59
       +
       

     

       60
       60
       +
       ### 5. add label listing tool

     

       61
       61
       +
       

     

       62
       62
       +
       users need to know what labels are available for a repo before they can use them.

     

       63
       63
       +
       

     

       64
       64
       +
       **new tool:**

     

       65
       65
       +
       ```python

     

       66
       66
       +
       list_repo_labels(repo: str) -> list[str]

     

       67
       67
       +
       # returns: ["wontfix", "duplicate", "good-first-issue", ...]

     

       68
       68
       +
       ```

     

       69
       69
       +
       

     

       70
       70
       +
       ### 6. pagination cursor handling

     

       71
       71
       +
       

     

       72
       72
       +
       currently returning raw cursor strings. consider:

     

       73
       73
       +
       - documenting cursor format

     

       74
       74
       +
       - providing helper for "has more pages" checking

     

       75
       75
       +
       - clear examples in docstrings

     

       76
       76
       +
       

     

       77
       77
       +
       ## completed improvements (this session)

     

       78
       78
       +
       

     

       79
       79
       +
       ### ✅ types architecture refactored

     

       80
       80
       +
       - moved from single `types.py` to `types/` directory

     

       81
       81
       +
       - separated concerns: `_common.py`, `_branches.py`, `_issues.py`

     

       82
       82
       +
       - public API in `__init__.py`

     

       83
       83
       +
       - parsing logic moved into types via `.from_api_response()` class methods

     

       84
       84
       +
       

     

       85
       85
       +
       ### ✅ proper validation with annotated types

     

       86
       86
       +
       - `RepoIdentifier = Annotated[str, AfterValidator(normalize_repo_identifier)]`

     

       87
       87
       +
       - strips `@` prefix automatically

     

       88
       88
       +
       - validates format before processing

     

       89
       89
       +
       

     

       90
       90
       +
       ### ✅ clickable URLs instead of AT Protocol internals

     

       91
       91
       +
       - issue operations return `https://tangled.org/@owner/repo/issues/N`

     

       92
       92
       +
       - removed useless `uri` and `cid` from user-facing responses

     

       93
       93
       +
       - URL generation encapsulated in types via `@computed_field`

     

       94
       94
       +
       

     

       95
       95
       +
       ### ✅ proper typing everywhere

     

       96
       96
       +
       - no more `dict[str, Any]` return types

     

       97
       97
       +
       - pydantic models for all results

     

       98
       98
       +
       - type safety throughout

     

       99
       99
       +
       

     

       100
       100
       +
       ### ✅ minimal test coverage

     

       101
       101
       +
       - 17 tests covering public contracts

     

       102
       102
       +
       - no implementation details tested

     

       103
       103
       +
       - validates key behaviors: URL generation, validation, parsing

     

       104
       104
       +
       

     

       105
       105
       +
       ### ✅ demo scripts

     

       106
       106
       +
       - full lifecycle demo

     

       107
       107
       +
       - URL format handling demo

     

       108
       108
       +
       - branch listing demo

     

       109
       109
       +
       - label manipulation demo (revealed silent failure issue)

     

       110
       110
       +
       

     

       111
       111
       +
       ### ✅ documentation improvements

     

       112
       112
       +
       - MCP client installation instructions in collapsible details

     

       113
       113
       +
       - clear usage examples for multiple clients

     

       114
       114
       +
       

     

       115
       115
       +
       ## technical debt

     

       116
       116
       +
       

     

       117
       117
       +
       ### remove unused types

     

       118
       118
       +
       - `RepoInfo`, `PullInfo`, `CreateRepoResult`, `GenericResult` - not used anywhere

     

       119
       119
       +
       - clean up or remove from public API

     

       120
       120
       +
       

     

       121
       121
       +
       ### consolidate URL generation logic

     

       122
       122
       +
       - `_tangled_issue_url()` helper was created to DRY the URL generation

     

       123
       123
       +
       - good pattern, consider extending to other URL types if needed

     

       124
       124
       +
       

     

       125
       125
       +
       ### consider lazy evaluation for expensive validations

     

       126
       126
       +
       - repo resolution happens on every tool call

     

       127
       127
       +
       - could cache repo metadata (knot, did) for duration of connection

     

       128
       128
       +
       - tradeoff: freshness vs performance

     

       129
       129
       +
       

     

       130
       130
       +
       ## priorities

     

       131
       131
       +
       

     

       132
       132
       +
       1. **critical:** fix label validation (fails silently)

     

       133
       133
       +
       2. **high:** add labels to list_repo_issues output

     

       134
       134
       +
       3. **medium:** add list_repo_labels tool

     

       135
       135
       +
       4. **medium:** fix pydantic warning

     

       136
       136
       +
       5. **low:** better error messages

     

       137
       137
       +
       6. **low:** clean up unused types

-74

src/tangled_mcp/types.py

···

       1
       1
       -
       """type definitions for tangled MCP server"""

     

       2
       2
       -
       

     

       3
       3
       -
       from typing import Any

     

       4
       4
       -
       

     

       5
       5
       -
       from pydantic import BaseModel, Field

     

       6
       6
       -
       

     

       7
       7
       -
       

     

       8
       8
       -
       class RepoInfo(BaseModel):

     

       9
       9
       -
           """repository information"""

     

       10
       10
       -
       

     

       11
       11
       -
           name: str

     

       12
       12
       -
           knot: str

     

       13
       13
       -
           description: str | None = None

     

       14
       14
       -
           created_at: str = Field(alias="createdAt")

     

       15
       15
       -
       

     

       16
       16
       -
       

     

       17
       17
       -
       class IssueInfo(BaseModel):

     

       18
       18
       -
           """issue information"""

     

       19
       19
       -
       

     

       20
       20
       -
           repo: str

     

       21
       21
       -
           title: str

     

       22
       22
       -
           body: str | None = None

     

       23
       23
       -
           created_at: str = Field(alias="createdAt")

     

       24
       24
       -
       

     

       25
       25
       -
       

     

       26
       26
       -
       class PullInfo(BaseModel):

     

       27
       27
       -
           """pull request information"""

     

       28
       28
       -
       

     

       29
       29
       -
           title: str

     

       30
       30
       -
           body: str | None = None

     

       31
       31
       -
           patch: str

     

       32
       32
       -
           target_repo: str

     

       33
       33
       -
           target_branch: str

     

       34
       34
       -
           source_branch: str | None = None

     

       35
       35
       -
           source_sha: str | None = None

     

       36
       36
       -
           created_at: str = Field(alias="createdAt")

     

       37
       37
       -
       

     

       38
       38
       -
       

     

       39
       39
       -
       class BranchInfo(BaseModel):

     

       40
       40
       -
           """branch information"""

     

       41
       41
       -
       

     

       42
       42
       -
           name: str

     

       43
       43
       -
           sha: str

     

       44
       44
       -
       

     

       45
       45
       -
       

     

       46
       46
       -
       class CreateIssueResult(BaseModel):

     

       47
       47
       -
           """result of creating an issue"""

     

       48
       48
       -
       

     

       49
       49
       -
           uri: str

     

       50
       50
       -
           success: bool = True

     

       51
       51
       -
           message: str = "issue created successfully"

     

       52
       52
       -
       

     

       53
       53
       -
       

     

       54
       54
       -
       class CreateRepoResult(BaseModel):

     

       55
       55
       -
           """result of creating a repository"""

     

       56
       56
       -
       

     

       57
       57
       -
           uri: str

     

       58
       58
       -
           success: bool = True

     

       59
       59
       -
           message: str = "repository created successfully"

     

       60
       60
       -
       

     

       61
       61
       -
       

     

       62
       62
       -
       class ListBranchesResult(BaseModel):

     

       63
       63
       -
           """result of listing branches"""

     

       64
       64
       -
       

     

       65
       65
       -
           branches: list[BranchInfo]

     

       66
       66
       -
           cursor: str | None = None

     

       67
       67
       -
       

     

       68
       68
       -
       

     

       69
       69
       -
       class GenericResult(BaseModel):

     

       70
       70
       -
           """generic operation result"""

     

       71
       71
       -
       

     

       72
       72
       -
           success: bool

     

       73
       73
       -
           message: str

     

       74
       74
       -
           data: dict[str, Any] | None = None

+22

src/tangled_mcp/types/__init__.py

···

       1
       1
       +
       """public types API for tangled MCP server"""

     

       2
       2
       +
       

     

       3
       3
       +
       from tangled_mcp.types._branches import BranchInfo, ListBranchesResult

     

       4
       4
       +
       from tangled_mcp.types._common import RepoIdentifier

     

       5
       5
       +
       from tangled_mcp.types._issues import (

     

       6
       6
       +
           CreateIssueResult,

     

       7
       7
       +
           DeleteIssueResult,

     

       8
       8
       +
           IssueInfo,

     

       9
       9
       +
           ListIssuesResult,

     

       10
       10
       +
           UpdateIssueResult,

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       __all__ = [

     

       14
       14
       +
           "BranchInfo",

     

       15
       15
       +
           "CreateIssueResult",

     

       16
       16
       +
           "DeleteIssueResult",

     

       17
       17
       +
           "IssueInfo",

     

       18
       18
       +
           "ListBranchesResult",

     

       19
       19
       +
           "ListIssuesResult",

     

       20
       20
       +
           "RepoIdentifier",

     

       21
       21
       +
           "UpdateIssueResult",

     

       22
       22
       +
       ]

+49

src/tangled_mcp/types/_branches.py

···

       1
       1
       +
       """branch-related types"""

     

       2
       2
       +
       

     

       3
       3
       +
       from typing import Any

     

       4
       4
       +
       

     

       5
       5
       +
       from pydantic import BaseModel

     

       6
       6
       +
       

     

       7
       7
       +
       

     

       8
       8
       +
       class BranchInfo(BaseModel):

     

       9
       9
       +
           """branch information"""

     

       10
       10
       +
       

     

       11
       11
       +
           name: str

     

       12
       12
       +
           sha: str

     

       13
       13
       +
       

     

       14
       14
       +
       

     

       15
       15
       +
       class ListBranchesResult(BaseModel):

     

       16
       16
       +
           """result of listing branches"""

     

       17
       17
       +
       

     

       18
       18
       +
           branches: list[BranchInfo]

     

       19
       19
       +
           cursor: str | None = None

     

       20
       20
       +
       

     

       21
       21
       +
           @classmethod

     

       22
       22
       +
           def from_api_response(cls, response: dict[str, Any]) -> "ListBranchesResult":

     

       23
       23
       +
               """construct from raw API response

     

       24
       24
       +
       

     

       25
       25
       +
               Args:

     

       26
       26
       +
                   response: raw response from tangled API with structure:

     

       27
       27
       +
                       {

     

       28
       28
       +
                           "branches": [

     

       29
       29
       +
                               {"reference": {"name": "main", "hash": "abc123"}},

     

       30
       30
       +
                               ...

     

       31
       31
       +
                           ],

     

       32
       32
       +
                           "cursor": "optional_cursor"

     

       33
       33
       +
                       }

     

       34
       34
       +
       

     

       35
       35
       +
               Returns:

     

       36
       36
       +
                   ListBranchesResult with parsed branches

     

       37
       37
       +
               """

     

       38
       38
       +
               branches = []

     

       39
       39
       +
               if "branches" in response:

     

       40
       40
       +
                   for branch_data in response["branches"]:

     

       41
       41
       +
                       ref = branch_data.get("reference", {})

     

       42
       42
       +
                       branches.append(

     

       43
       43
       +
                           BranchInfo(

     

       44
       44
       +
                               name=ref.get("name", ""),

     

       45
       45
       +
                               sha=ref.get("hash", ""),

     

       46
       46
       +
                           )

     

       47
       47
       +
                       )

     

       48
       48
       +
       

     

       49
       49
       +
               return cls(branches=branches, cursor=response.get("cursor"))

+18

src/tangled_mcp/types/_common.py

···

       1
       1
       +
       """shared types and validators"""

     

       2
       2
       +
       

     

       3
       3
       +
       from typing import Annotated

     

       4
       4
       +
       

     

       5
       5
       +
       from pydantic import AfterValidator

     

       6
       6
       +
       

     

       7
       7
       +
       

     

       8
       8
       +
       def normalize_repo_identifier(v: str) -> str:

     

       9
       9
       +
           """normalize repo identifier to owner/repo format without @ prefix"""

     

       10
       10
       +
           if "/" not in v:

     

       11
       11
       +
               raise ValueError(f"invalid repo format: '{v}'. expected 'owner/repo'")

     

       12
       12
       +
           owner, repo_name = v.split("/", 1)

     

       13
       13
       +
           # strip @ from owner if present

     

       14
       14
       +
           owner = owner.lstrip("@")

     

       15
       15
       +
           return f"{owner}/{repo_name}"

     

       16
       16
       +
       

     

       17
       17
       +
       

     

       18
       18
       +
       RepoIdentifier = Annotated[str, AfterValidator(normalize_repo_identifier)]

+89

tests/test_types.py

···

       1
       1
       +
       """tests for public types API"""

     

       2
       2
       +
       

     

       3
       3
       +
       import pytest

     

       4
       4
       +
       from pydantic import ValidationError

     

       5
       5
       +
       

     

       6
       6
       +
       from tangled_mcp.types import (

     

       7
       7
       +
           CreateIssueResult,

     

       8
       8
       +
           ListBranchesResult,

     

       9
       9
       +
           UpdateIssueResult,

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       

     

       13
       13
       +
       class TestRepoIdentifierValidation:

     

       14
       14
       +
           """test RepoIdentifier validation behavior"""

     

       15
       15
       +
       

     

       16
       16
       +
           def test_strips_at_prefix(self):

     

       17
       17
       +
               """@ prefix is stripped during validation"""

     

       18
       18
       +
               result = CreateIssueResult(repo="@owner/repo", issue_id=1)

     

       19
       19
       +
               assert result.repo == "owner/repo"

     

       20
       20
       +
       

     

       21
       21
       +
           def test_accepts_without_at_prefix(self):

     

       22
       22
       +
               """repo identifier without @ works"""

     

       23
       23
       +
               result = CreateIssueResult(repo="owner/repo", issue_id=1)

     

       24
       24
       +
               assert result.repo == "owner/repo"

     

       25
       25
       +
       

     

       26
       26
       +
           def test_rejects_invalid_format(self):

     

       27
       27
       +
               """repo identifier without slash is rejected"""

     

       28
       28
       +
               with pytest.raises(ValidationError, match="invalid repo format"):

     

       29
       29
       +
                   CreateIssueResult(repo="invalid", issue_id=1)

     

       30
       30
       +
       

     

       31
       31
       +
       

     

       32
       32
       +
       class TestIssueResultURLs:

     

       33
       33
       +
           """test issue result URL generation"""

     

       34
       34
       +
       

     

       35
       35
       +
           def test_create_issue_url(self):

     

       36
       36
       +
               """create result generates correct tangled.org URL"""

     

       37
       37
       +
               result = CreateIssueResult(repo="owner/repo", issue_id=42)

     

       38
       38
       +
               assert result.url == "https://tangled.org/@owner/repo/issues/42"

     

       39
       39
       +
       

     

       40
       40
       +
           def test_update_issue_url(self):

     

       41
       41
       +
               """update result generates correct tangled.org URL"""

     

       42
       42
       +
               result = UpdateIssueResult(repo="owner/repo", issue_id=42)

     

       43
       43
       +
               assert result.url == "https://tangled.org/@owner/repo/issues/42"

     

       44
       44
       +
       

     

       45
       45
       +
           def test_url_handles_at_prefix_input(self):

     

       46
       46
       +
               """URL is correct even when input has @ prefix"""

     

       47
       47
       +
               result = CreateIssueResult(repo="@owner/repo", issue_id=42)

     

       48
       48
       +
               assert result.url == "https://tangled.org/@owner/repo/issues/42"

     

       49
       49
       +
       

     

       50
       50
       +
       

     

       51
       51
       +
       class TestListBranchesFromAPIResponse:

     

       52
       52
       +
           """test ListBranchesResult.from_api_response constructor"""

     

       53
       53
       +
       

     

       54
       54
       +
           def test_parses_branch_data(self):

     

       55
       55
       +
               """parses branches from API response structure"""

     

       56
       56
       +
               response = {

     

       57
       57
       +
                   "branches": [

     

       58
       58
       +
                       {"reference": {"name": "main", "hash": "abc123"}},

     

       59
       59
       +
                       {"reference": {"name": "dev", "hash": "def456"}},

     

       60
       60
       +
                   ],

     

       61
       61
       +
                   "cursor": "next_page",

     

       62
       62
       +
               }

     

       63
       63
       +
       

     

       64
       64
       +
               result = ListBranchesResult.from_api_response(response)

     

       65
       65
       +
       

     

       66
       66
       +
               assert len(result.branches) == 2

     

       67
       67
       +
               assert result.branches[0].name == "main"

     

       68
       68
       +
               assert result.branches[0].sha == "abc123"

     

       69
       69
       +
               assert result.branches[1].name == "dev"

     

       70
       70
       +
               assert result.branches[1].sha == "def456"

     

       71
       71
       +
               assert result.cursor == "next_page"

     

       72
       72
       +
       

     

       73
       73
       +
           def test_handles_missing_cursor(self):

     

       74
       74
       +
               """cursor is optional in API response"""

     

       75
       75
       +
               response = {"branches": [{"reference": {"name": "main", "hash": "abc123"}}]}

     

       76
       76
       +
       

     

       77
       77
       +
               result = ListBranchesResult.from_api_response(response)

     

       78
       78
       +
       

     

       79
       79
       +
               assert len(result.branches) == 1

     

       80
       80
       +
               assert result.cursor is None

     

       81
       81
       +
       

     

       82
       82
       +
           def test_handles_empty_branches(self):

     

       83
       83
       +
               """handles empty branches list"""

     

       84
       84
       +
               response = {"branches": []}

     

       85
       85
       +
       

     

       86
       86
       +
               result = ListBranchesResult.from_api_response(response)

     

       87
       87
       +
       

     

       88
       88
       +
               assert result.branches == []

     

       89
       89
       +
               assert result.cursor is None

src/tangled_mcp/_tangled/__init__.py

···

       10
       10
        
           create_issue,

     

       11
       11
        
           delete_issue,

     

       12
       12
        
           list_repo_issues,

     

       13
       13
       +
           list_repo_labels,

     

       13
       14
        
           update_issue,

     

       14
       15
        
       )

     

       15
       16
        
       

     
···

       21
       22
        
           "update_issue",

     

       22
       23
        
           "delete_issue",

     

       23
       24
        
           "list_repo_issues",

     

       25
       25
       +
           "list_repo_labels",

     

       24
       26
        
           "resolve_repo_identifier",

     

       25
       27
        
       ]

+121

src/tangled_mcp/_tangled/_issues.py

···

       377
       377
        
       

     

       378
       378
        
           # filter issues by repo

     

       379
       379
        
           issues = []

     

       380
       380
       +
           issue_uris = []

     

       380
       381
        
           for record in response.records:

     

       381
       382
        
               if (

     

       382
       383
        
                   repo := getattr(record.value, "repo", None)

     

       383
       384
        
               ) is not None and repo == repo_at_uri:

     

       385
       385
       +
                   issue_uris.append(record.uri)

     

       384
       386
        
                   issues.append(

     

       385
       387
        
                       {

     

       386
       388
        
                           "uri": record.uri,

     
···

       389
       391
        
                           "title": getattr(record.value, "title", ""),

     

       390
       392
        
                           "body": getattr(record.value, "body", None),

     

       391
       393
        
                           "createdAt": getattr(record.value, "createdAt", ""),

     

       394
       394
       +
                           "labels": [],  # will be populated below

     

       392
       395
        
                       }

     

       393
       396
        
                   )

     

       394
       397
        
       

     

       398
       398
       +
           # fetch label ops and correlate with issues

     

       399
       399
       +
           if issue_uris:

     

       400
       400
       +
               label_ops = client.com.atproto.repo.list_records(

     

       401
       401
       +
                   models.ComAtprotoRepoListRecords.Params(

     

       402
       402
       +
                       repo=client.me.did,

     

       403
       403
       +
                       collection="sh.tangled.label.op",

     

       404
       404
       +
                       limit=100,

     

       405
       405
       +
                   )

     

       406
       406
       +
               )

     

       407
       407
       +
       

     

       408
       408
       +
               # build map of issue_uri -> current label URIs

     

       409
       409
       +
               issue_labels_map: dict[str, set[str]] = {uri: set() for uri in issue_uris}

     

       410
       410
       +
               for op_record in label_ops.records:

     

       411
       411
       +
                   if hasattr(op_record.value, "subject") and op_record.value.subject in issue_labels_map:

     

       412
       412
       +
                       subject_uri = op_record.value.subject

     

       413
       413
       +
                       if hasattr(op_record.value, "add"):

     

       414
       414
       +
                           for operand in op_record.value.add:

     

       415
       415
       +
                               if hasattr(operand, "key"):

     

       416
       416
       +
                                   issue_labels_map[subject_uri].add(operand.key)

     

       417
       417
       +
                       if hasattr(op_record.value, "delete"):

     

       418
       418
       +
                           for operand in op_record.value.delete:

     

       419
       419
       +
                               if hasattr(operand, "key"):

     

       420
       420
       +
                                   issue_labels_map[subject_uri].discard(operand.key)

     

       421
       421
       +
       

     

       422
       422
       +
               # extract label names from URIs and add to issues

     

       423
       423
       +
               for issue in issues:

     

       424
       424
       +
                   label_uris = issue_labels_map.get(issue["uri"], set())

     

       425
       425
       +
                   issue["labels"] = [uri.split("/")[-1] for uri in label_uris]

     

       426
       426
       +
       

     

       395
       427
        
           return {"issues": issues, "cursor": response.cursor}

     

       396
       428
        
       

     

       397
       429
        
       

     

       430
       430
       +
       def list_repo_labels(repo_id: str) -> list[str]:

     

       431
       431
       +
           """list available labels for a repository

     

       432
       432
       +
       

     

       433
       433
       +
           Args:

     

       434
       434
       +
               repo_id: repository identifier in "did/repo" format

     

       435
       435
       +
       

     

       436
       436
       +
           Returns:

     

       437
       437
       +
               list of available label names for the repo

     

       438
       438
       +
           """

     

       439
       439
       +
           client = _get_authenticated_client()

     

       440
       440
       +
       

     

       441
       441
       +
           if not client.me:

     

       442
       442
       +
               raise RuntimeError("client not authenticated")

     

       443
       443
       +
       

     

       444
       444
       +
           # parse repo_id to get owner_did and repo_name

     

       445
       445
       +
           if "/" not in repo_id:

     

       446
       446
       +
               raise ValueError(f"invalid repo_id format: {repo_id}")

     

       447
       447
       +
       

     

       448
       448
       +
           owner_did, repo_name = repo_id.split("/", 1)

     

       449
       449
       +
       

     

       450
       450
       +
           # get the repo's subscribed label definitions

     

       451
       451
       +
           records = client.com.atproto.repo.list_records(

     

       452
       452
       +
               models.ComAtprotoRepoListRecords.Params(

     

       453
       453
       +
                   repo=owner_did,

     

       454
       454
       +
                   collection="sh.tangled.repo",

     

       455
       455
       +
                   limit=100,

     

       456
       456
       +
               )

     

       457
       457
       +
           )

     

       458
       458
       +
       

     

       459
       459
       +
           repo_labels: list[str] = []

     

       460
       460
       +
           for record in records.records:

     

       461
       461
       +
               if (

     

       462
       462
       +
                   name := getattr(record.value, "name", None)

     

       463
       463
       +
               ) is not None and name == repo_name:

     

       464
       464
       +
                   if (subscribed_labels := getattr(record.value, "labels", None)) is not None:

     

       465
       465
       +
                       # extract label names from URIs

     

       466
       466
       +
                       repo_labels = [uri.split("/")[-1] for uri in subscribed_labels]

     

       467
       467
       +
                   break

     

       468
       468
       +
       

     

       469
       469
       +
           if not repo_labels and not any(

     

       470
       470
       +
               (name := getattr(r.value, "name", None)) and name == repo_name

     

       471
       471
       +
               for r in records.records

     

       472
       472
       +
           ):

     

       473
       473
       +
               raise ValueError(f"repo not found: {repo_id}")

     

       474
       474
       +
       

     

       475
       475
       +
           return repo_labels

     

       476
       476
       +
       

     

       477
       477
       +
       

     

       398
       478
        
       def _get_current_labels(client, issue_uri: str) -> set[str]:

     

       399
       479
        
           """get current labels applied to an issue by examining all label ops"""

     

       400
       480
        
           label_ops = client.com.atproto.repo.list_records(

     
···

       421
       501
        
           return current_labels

     

       422
       502
        
       

     

       423
       503
        
       

     

       504
       504
       +
       def _validate_labels(labels: list[str], repo_labels: list[str]) -> None:

     

       505
       505
       +
           """validate that all requested labels exist in the repo's subscribed labels

     

       506
       506
       +
       

     

       507
       507
       +
           Args:

     

       508
       508
       +
               labels: list of label names or URIs to validate

     

       509
       509
       +
               repo_labels: list of label definition URIs the repo subscribes to

     

       510
       510
       +
       

     

       511
       511
       +
           Raises:

     

       512
       512
       +
               ValueError: if any labels are invalid, listing available labels

     

       513
       513
       +
           """

     

       514
       514
       +
           # extract available label names from repo's subscribed label URIs

     

       515
       515
       +
           available_labels = [uri.split("/")[-1] for uri in repo_labels]

     

       516
       516
       +
       

     

       517
       517
       +
           # check each requested label

     

       518
       518
       +
           invalid_labels = []

     

       519
       519
       +
           for label in labels:

     

       520
       520
       +
               if label.startswith("at://"):

     

       521
       521
       +
                   # if it's a full URI, check if it's in repo_labels

     

       522
       522
       +
                   if label not in repo_labels:

     

       523
       523
       +
                       invalid_labels.append(label)

     

       524
       524
       +
               else:

     

       525
       525
       +
                   # if it's a name, check if it matches any available label

     

       526
       526
       +
                   if not any(

     

       527
       527
       +
                       label.lower() == available.lower() for available in available_labels

     

       528
       528
       +
                   ):

     

       529
       529
       +
                       invalid_labels.append(label)

     

       530
       530
       +
       

     

       531
       531
       +
           # fail loudly if any labels are invalid

     

       532
       532
       +
           if invalid_labels:

     

       533
       533
       +
               raise ValueError(

     

       534
       534
       +
                   f"invalid labels: {invalid_labels}\n"

     

       535
       535
       +
                   f"available labels for this repo: {sorted(available_labels)}"

     

       536
       536
       +
               )

     

       537
       537
       +
       

     

       538
       538
       +
       

     

       424
       539
        
       def _apply_labels(

     

       425
       540
        
           client,

     

       426
       541
        
           issue_uri: str,

     
···

       436
       551
        
               labels: list of label names or URIs to apply

     

       437
       552
        
               repo_labels: list of label definition URIs the repo subscribes to

     

       438
       553
        
               current_labels: set of currently applied label URIs

     

       554
       554
       +
       

     

       555
       555
       +
           Raises:

     

       556
       556
       +
               ValueError: if any labels are invalid (via _validate_labels)

     

       439
       557
        
           """

     

       558
       558
       +
           # validate labels before attempting to apply

     

       559
       559
       +
           _validate_labels(labels, repo_labels)

     

       560
       560
       +
       

     

       440
       561
        
           # resolve label names to URIs

     

       441
       562
        
           new_label_uris = set()

     

       442
       563
        
           for label in labels:

+1 -1

src/tangled_mcp/settings.py

···

       10
       10
        
       

     

       11
       11
        
           # optional: specify PDS URL if auto-discovery doesn't work

     

       12
       12
        
           # leave empty for auto-discovery from handle

     

       13
       13
       -
           tangled_pds_url: str | None = Field(default=None)

     

       13
       13
       +
           tangled_pds_url: str | None = None

     

       14
       14
        
       

     

       15
       15
        
       

     

       16
       16
        
       # tangled service constants

+2 -1

tests/test_server.py

···

       22
       22
        
               async with Client(tangled_mcp) as client:

     

       23
       23
        
                   tools = await client.list_tools()

     

       24
       24
        
       

     

       25
       25
       -
                   assert len(tools) == 5

     

       25
       25
       +
                   assert len(tools) == 6

     

       26
       26
        
       

     

       27
       27
        
                   tool_names = {tool.name for tool in tools}

     

       28
       28
        
                   assert "list_repo_branches" in tool_names

     
···

       30
       30
        
                   assert "update_repo_issue" in tool_names

     

       31
       31
        
                   assert "delete_repo_issue" in tool_names

     

       32
       32
        
                   assert "list_repo_issues" in tool_names

     

       33
       33
       +
                   assert "list_repo_labels" in tool_names

     

       33
       34
        
       

     

       34
       35
        
           async def test_list_repo_branches_tool_schema(self):

     

       35
       36
        
               """test list_repo_branches tool has correct schema"""