# feat(control-plane): resolve repos by name with --project scope `eb7fb56`· toothbrush·3w ago·4 files·+132 added/-14 removed repo get/delete and grant repo add/list/remove now accept a repo name (not just a ULID) when --project is given to scope the lookup — repo names are unique only within a project. A ULID still passes through unchanged and ignores --project. Co-Authored-By: Claude Opus 4.8 (1M context) ## Sessions ab8e423ff72fView transcript ## Changes 4 - cmd/entire/cli - Mgrant.go+24/-7 - Mrepo.go+24/-7 - Mresolveref.go+47 - Mresolveref_test.go+37 ``` 347 unmodified lines func newGrantRepoAddCmd() *cobra.Command { var provider, providerUserID, role, granteeType string var provider, providerUserID, role, granteeType, project string cmd := &cobra.Command{ Use: "add ", Short: "Grant access to a repo", } bindGranteeFlags(cmd, &provider, &providerUserID) cmd.Flags().StringVar(&role, "role", "", "repo role (required)") cmd.Flags().StringVar(&granteeType, "grantee-type", "", "grantee kind: account, org, or team (default account)") bindRepoProjectFlag(cmd, &project) markRequired(cmd, "role") return cmd } func newGrantRepoListCmd() *cobra.Command { return &cobra.Command{ var project string cmd := &cobra.Command{ Use: "list ", Short: "List repo grants", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { return runCoreList(cmd, projectGrantColumns, repoGrantRow, func(ctx context.Context, c *coreapi.Client) ([]coreapi.RepoGrant, error) { out, err := c.ListRepoGrants(ctx, coreapi.ListRepoGrantsParams{RepoId: args[0]}) repoID, err := resolveRepoRef(ctx, c, args[0], project) if err != nil { return nil, err } out, err := c.ListRepoGrants(ctx, coreapi.ListRepoGrantsParams{RepoId: repoID}) if err != nil { return nil, err } }) }, } bindRepoProjectFlag(cmd, &project) return cmd } func newGrantRepoRemoveCmd() *cobra.Command { var granteeType, granteeID, provider, providerUserID string var granteeType, granteeID, provider, providerUserID, project string cmd := &cobra.Command{ Use: "remove ", Short: "Revoke repo access from a grantee", } return cmd } ``` Mcmd/entire/cli/grant.go+24/-7 ``` 150 unmodified lines func newRepoGetCmd() *cobra.Command { return &cobra.Command{ var project string cmd := &cobra.Command{ Use: "get ", Short: "Show a repository by ULID", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { return runCoreObject(cmd, repoColumns, repoRow, func(ctx context.Context, c *coreapi.Client) (*coreapi.Repo, error) { sc, err := c.GetRepo(ctx, coreapi.GetRepoParams{RepoId: args[0]}) repoID, err := resolveRepoRef(ctx, c, args[0], project) if err != nil { return nil, err } return sc, nil }) }, } bindRepoProjectFlag(cmd, &project) return cmd } func newRepoDeleteCmd() *cobra.Command { return &cobra.Command{ var project string cmd := &cobra.Command{ Use: "delete ", Short: "Delete a repository by ULID", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { return runCore(cmd, func(ctx context.Context, c *coreapi.Client) error { if err := c.DeleteRepo(ctx, coreapi.DeleteRepoParams{RepoId: args[0]}); err != nil { repoID, err := resolveRepoRef(ctx, c, args[0], project) if err != nil { return err } if err := c.DeleteRepo(ctx, coreapi.DeleteRepoParams{RepoId: repoID}); err != nil { return err } cmd.Printf("Deleted repo %s\n", args[0]) } }) } } bindRepoProjectFlag(cmd, &project) return cmd } // bindRepoProjectFlag wires the shared --project scope used to resolve a repo // addressed by name (a repo name is unique only within its project). Ignored // when the repo arg is already a ULID. func bindRepoProjectFlag(cmd *cobra.Command, project *string) { cmd.Flags().StringVar(project, "project", "", "owning project (name or ULID); required when is a name") } ``` Mcmd/entire/cli/repo.go+24/-7 ``` 145 unmodified lines func resolveRepoRef(ctx context.Context, c *coreapi.Client, ref, projectRef string) (string, error) { if looksLikeULID(ref) { return ref, nil } if projectRef == "" { return "", fmt.Errorf("repo %q is a name; pass --project to resolve it, or use a repo ULID", ref) } projID, err := resolveProjectRef(ctx, c, projectRef) if err != nil { return "", err } out, err := c.ListProjectRepos(ctx, coreapi.ListProjectReposParams{ProjectId: projID}) if err != nil { return "", err } return pickRepo(out.Repos, ref) } // pickRepo selects the single repo named name within an already-scoped project // listing. Repo names are unique per project, so a name matches at most one; // zero is an error pointing at `repo list`, and (defensively) multiple lists // the colliding ids. func pickRepo(repos []coreapi.Repo, name string) (string, error) { var matches []coreapi.Repo for _, r := range repos { if r.Name == name { matches = append(matches, r) } } switch len(matches) { case 1: return matches[0].ID, nil case 0: return "", fmt.Errorf("no repo named %q in that project (run `entire repo list ` to see names, or pass a ULID)", name) default: ids := make([]string, len(matches)) for i, r := range matches { ids[i] = r.ID } return "", fmt.Errorf("repo name %q is ambiguous (%s); pass a ULID instead", name, strings.Join(ids, ", ")) } } // filterProjectsByName narrows projects to exact name matches, returning all of // them when name is empty. Used by `project list --org` to apply --name // client-side, since the org-scoped list endpoint has no name parameter. ``` Mcmd/entire/cli/resolveref.go+47 ``` 142 unmodified lines func TestPickRepo(t *testing.T) { t.Parallel() repos := []coreapi.Repo{ {ID: "01J0REPO000000000000000001", Name: "api"}, {ID: "01J0REPO000000000000000002", Name: "web"}, } t.Run("unique match", func(t *testing.T) { t.Parallel() got, err := pickRepo(repos, "web") if err != nil { t.Fatalf("pickRepo: %v", err) } if got != "01J0REPO000000000000000002" { t.Errorf("pickRepo = %q, want web id", got) } }) t.Run("no match", func(t *testing.T) { t.Parallel() if _, err := pickRepo(repos, "missing"); err == nil { t.Error("pickRepo expected error for unknown name") } }) t.Run("ambiguous", func(t *testing.T) { t.Parallel() dupes := []coreapi.Repo{ {ID: "01J0REPO00000000000000000A", Name: "dup"}, {ID: "01J0REPO00000000000000000B", Name: "dup"}, } if _, err := pickRepo(dupes, "dup"); err == nil { t.Error("pickRepo expected error for ambiguous name") } }) } func TestFilterProjectsByName(t *testing.T) { t.Parallel() projects := []coreapi.Project{ ```