add owner/repo resolution, switch to uv-dynamic-versioning

CLAUDE.md

···
-# tangled-mcp project notes
+# tangled-mcp notes
 
 ## dependencies
-- `uv add` only - NEVER `uv pip`
-- atproto from PR #605 (service auth support)
-
-## architecture
-- auth: PDS login → `getServiceAuth` → tangled XRPC
-- `TANGLED_APPVIEW_URL` + `TANGLED_DID` are constants (not user-configurable)
-- `TANGLED_PDS_URL` optional (auto-discovery from handle unless custom PDS)
+- `uv add` only (NEVER `uv pip`)
+- atproto from PR #605 (service auth)
+- pydantic warning filtered (upstream atproto issue #625)
 
 ## deployment
-- primary development on github (CI/deployment via FastMCP Cloud)
-- mirrored to tangled for dogfooding/showcase
-- single `git push origin main` pushes to both remotes
-- use `just push "message"` for convenience
-- **primary**: https://github.com/zzstoatzz/tangled-mcp
-- **mirror**: [e-mail]:zzstoatzz.io/tangled-mcp
-- think of github as source of truth since that's where deployment happens
+- **primary**: https://github.com/zzstoatzz/tangled-mcp (FastMCP Cloud)
+- **mirror**: tangled.sh:zzstoatzz.io/tangled-mcp (dogfooding)
+- `git push origin main` → both remotes
 
-## code quality
-- ruff: import sorting (I), pyupgrade (UP)
-- ty: type checking configured
-- pre-commit: ruff only
-- justfile: setup, test, check, push
-
-## testing
-- use in-memory transport (pass FastMCP directly to Client)
-- pytest asyncio_mode = "auto" (never add `@pytest.mark.asyncio`)
+## tools
+- all accept `owner/repo` format (e.g., `zzstoatzz/tangled-mcp`)
+- server-side resolution: handle → DID → repo AT-URI
 
-## anti-patterns
-- don't expose service URLs as user settings
-- don't use deferred imports (unless absolutely necessary)
+## dev
+- justfile: `setup`, `test`, `check`, `push`
+- versioning: uv-dynamic-versioning (git tags)
+- type checking: ty + ruff (I, UP)

README.md

···
 
 ## tools
 
+all tools accept repositories in `owner/repo` format (e.g., `zzstoatzz/tangled-mcp`). handles (with or without `@` prefix) and DIDs are both supported for the owner.
+
 ### repositories
 - `list_repo_branches(repo, limit, cursor)` - list branches for a repository
 

pyproject.toml

···
 [project]
 name = "tangled-mcp"
-version = "0.1.0"
+dynamic = ["version"]
 description = "MCP server for Tangled git collaboration platform"
 readme = "README.md"
 authors = [{ name = "nate", email = "[e-mail]" }]
···
 tangled-mcp = "tangled_mcp.__main__:main"
 
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "uv-dynamic-versioning>=0.7.0"]
 build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+vcs = "git"
+style = "pep440"
+bump = true
+fallback-version = "0.0.0"
 
 [tool.hatch.metadata]
 allow-direct-references = true

src/tangled_mcp/__init__.py

···
 """tangled MCP server"""
 
-__version__ = "0.1.0"
+try:
+    from importlib.metadata import version
+
+    __version__ = version("tangled-mcp")
+except Exception:
+    __version__ = "0.0.0"

src/tangled_mcp/_tangled/__init__.py

···
     get_service_token,
     list_branches,
     list_repo_issues,
+    resolve_repo_identifier,
 )
 
 __all__ = [
···
     "list_branches",
     "create_issue",
     "list_repo_issues",
+    "resolve_repo_identifier",
 ]

src/tangled_mcp/_tangled/_client.py

···
 from tangled_mcp.settings import TANGLED_APPVIEW_URL, TANGLED_DID, settings
 
 
+def resolve_repo_identifier(owner_slash_repo: str) -> str:
+    """resolve owner/repo format to repository AT-URI
+
+    Args:
+        owner_slash_repo: repository identifier in "owner/repo" format
+                         (e.g., "zzstoatzz/tangled-mcp")
+
+    Returns:
+        repository AT-URI (e.g., "at://did:plc:.../sh.tangled.repo.repo/...")
+
+    Raises:
+        ValueError: if format is invalid or repo not found
+    """
+    if "/" not in owner_slash_repo:
+        raise ValueError(
+            f"invalid repo format: '{owner_slash_repo}'. expected 'owner/repo'"
+        )
+
+    owner, repo_name = owner_slash_repo.split("/", 1)
+    client = _get_authenticated_client()
+
+    # resolve owner (handle or DID) to DID
+    if owner.startswith("did:"):
+        owner_did = owner
+    else:
+        # strip @ prefix if present
+        owner = owner.lstrip("@")
+        # resolve handle to DID
+        try:
+            response = client.com.atproto.identity.resolve_handle(
+                params={"handle": owner}
+            )
+            owner_did = response.did
+        except Exception as e:
+            raise ValueError(f"failed to resolve handle '{owner}': {e}") from e
+
+    # query owner's repo collection to find repo by name
+    try:
+        records = client.com.atproto.repo.list_records(
+            models.ComAtprotoRepoListRecords.Params(
+                repo=owner_did,
+                collection="sh.tangled.repo.repo",
+                limit=100,  # should be enough for most users
+            )
+        )
+    except Exception as e:
+        raise ValueError(f"failed to list repos for '{owner}': {e}") from e
+
+    # find repo with matching name
+    for record in records.records:
+        if hasattr(record.value, "name") and record.value.name == repo_name:
+            return record.uri
+
+    raise ValueError(f"repo '{repo_name}' not found for owner '{owner}'")
+
+
 def _get_authenticated_client() -> Client:
     """get authenticated AT Protocol client
 

src/tangled_mcp/server.py

···
 def list_repo_branches(
     repo: Annotated[
         str,
-        Field(description="repository identifier in format 'did:plc:.../repoName'"),
+        Field(
+            description="repository identifier in 'owner/repo' format (e.g., 'zzstoatzz/tangled-mcp')"
+        ),
     ],
     limit: Annotated[
         int, Field(ge=1, le=100, description="maximum number of branches to return")
···
     """list branches for a repository
 
     Args:
-        repo: repository identifier (e.g., 'did:plc:.../repoName')
+        repo: repository identifier in 'owner/repo' format (e.g., 'zzstoatzz/tangled-mcp')
         limit: maximum number of branches to return (1-100)
         cursor: optional pagination cursor
 
     Returns:
         list of branches with optional cursor for pagination
     """
-    response = _tangled.list_branches(repo, limit, cursor)
+    # resolve owner/repo to AT-URI
+    repo_uri = _tangled.resolve_repo_identifier(repo)
+    response = _tangled.list_branches(repo_uri, limit, cursor)
 
     # parse response into BranchInfo objects
     branches = []
···
     repo: Annotated[
         str,
         Field(
-            description="repository AT-URI (e.g., 'at://did:plc:.../sh.tangled.repo.repo/...')"
+            description="repository identifier in 'owner/repo' format (e.g., 'zzstoatzz/tangled-mcp')"
         ),
     ],
     title: Annotated[str, Field(description="issue title")],
···
     """create an issue on a repository
 
     Args:
-        repo: repository AT-URI
+        repo: repository identifier in 'owner/repo' format
         title: issue title
         body: optional issue body/description
 
     Returns:
         dict with uri and cid of created issue
     """
-    response = _tangled.create_issue(repo, title, body)
+    # resolve owner/repo to AT-URI
+    repo_uri = _tangled.resolve_repo_identifier(repo)
+    response = _tangled.create_issue(repo_uri, title, body)
     return {"uri": response["uri"], "cid": response["cid"]}
 
 
···
 def list_repo_issues(
     repo: Annotated[
         str,
-        Field(description="repository AT-URI to filter issues by"),
+        Field(
+            description="repository identifier in 'owner/repo' format (e.g., 'zzstoatzz/tangled-mcp')"
+        ),
     ],
     limit: Annotated[
         int, Field(ge=1, le=100, description="maximum number of issues to return")
···
     """list issues for a repository
 
     Args:
-        repo: repository AT-URI to filter by
+        repo: repository identifier in 'owner/repo' format
         limit: maximum number of issues to return (1-100)
         cursor: optional pagination cursor
 
     Returns:
         dict with list of issues and optional cursor
     """
-    response = _tangled.list_repo_issues(repo, limit, cursor)
+    # resolve owner/repo to AT-URI
+    repo_uri = _tangled.resolve_repo_identifier(repo)
+    response = _tangled.list_repo_issues(repo_uri, limit, cursor)
 
     return {
         "issues": response["issues"],

tests/test_resolver.py

···
+"""tests for repository identifier resolution"""
+
+import pytest
+
+
+class TestRepoIdentifierParsing:
+    """test repository identifier format validation"""
+
+    def test_invalid_format_no_slash(self):
+        """test that identifiers without slash are rejected"""
+        from tangled_mcp._tangled._client import resolve_repo_identifier
+
+        with pytest.raises(ValueError, match="invalid repo format.*expected 'owner/repo'"):
+            resolve_repo_identifier("invalid")
+
+    def test_invalid_format_empty(self):
+        """test that empty identifiers are rejected"""
+        from tangled_mcp._tangled._client import resolve_repo_identifier
+
+        with pytest.raises(ValueError, match="invalid repo format.*expected 'owner/repo'"):
+            resolve_repo_identifier("")
+
+    def test_valid_format_with_handle(self):
+        """test that valid owner/repo format is accepted (parsing only)"""
+        # note: we can't actually test resolution without credentials
+        # but we can test that the format parsing works
+        from tangled_mcp._tangled._client import resolve_repo_identifier
+
+        # this will fail at the resolution step, but not at parsing
+        with pytest.raises(Exception):  # will fail during actual resolution
+            resolve_repo_identifier("owner/repo")
+
+    def test_valid_format_with_at_prefix(self):
+        """test that @owner/repo format is accepted"""
+        from tangled_mcp._tangled._client import resolve_repo_identifier
+
+        # this will fail at the resolution step, but not at parsing
+        with pytest.raises(Exception):  # will fail during actual resolution
+            resolve_repo_identifier("@owner/repo")
+
+    def test_valid_format_with_did(self):
+        """test that did:plc:.../repo format is accepted"""
+        from tangled_mcp._tangled._client import resolve_repo_identifier
+
+        # this will fail at the resolution step, but not at parsing
+        with pytest.raises(Exception):  # will fail during actual resolution
+            resolve_repo_identifier("did:plc:test123/repo")

uv.lock

···
 
 [[package]]
 name = "tangled-mcp"
-version = "0.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "atproto" },